]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add more art IDs
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxFileConfig swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1662 {
1663 long v = 0;
1664 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1665 SWIG_type_error("unsigned number", obj);
1666 }
1667 else if (val)
1668 *val = (unsigned long)v;
1669 return 1;
1670 }
1671
1672
1673 SWIGINTERNSHORT unsigned long
1674 SWIG_As_unsigned_SS_long(PyObject* obj)
1675 {
1676 unsigned long v;
1677 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1678 /*
1679 this is needed to make valgrind/purify happier.
1680 */
1681 memset((void*)&v, 0, sizeof(unsigned long));
1682 }
1683 return v;
1684 }
1685
1686
1687 SWIGINTERNSHORT int
1688 SWIG_Check_unsigned_SS_long(PyObject* obj)
1689 {
1690 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1691 }
1692
1693
1694 SWIGINTERNSHORT PyObject*
1695 SWIG_From_unsigned_SS_long(unsigned long value)
1696 {
1697 return (value > LONG_MAX) ?
1698 PyLong_FromUnsignedLong(value)
1699 : PyInt_FromLong((long)(value));
1700 }
1701
1702
1703 bool wxThread_IsMain() {
1704 #ifdef WXP_WITH_THREAD
1705 return wxThread::IsMain();
1706 #else
1707 return true;
1708 #endif
1709 }
1710
1711 static void wxCaret_Destroy(wxCaret *self){
1712 delete self;
1713 }
1714
1715 #include <wx/snglinst.h>
1716
1717
1718 #include <wx/tipdlg.h>
1719
1720
1721 class wxPyTipProvider : public wxTipProvider {
1722 public:
1723 wxPyTipProvider(size_t currentTip)
1724 : wxTipProvider(currentTip) {}
1725
1726 DEC_PYCALLBACK_STRING__pure(GetTip);
1727 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1728 PYPRIVATE;
1729 };
1730
1731 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1732 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1733
1734
1735 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1736
1737 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1738
1739 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1740 : wxTimer(owner, id)
1741 {
1742 if (owner == NULL) SetOwner(this);
1743 }
1744
1745
1746 void wxPyTimer::Notify() {
1747 bool found;
1748 bool blocked = wxPyBeginBlockThreads();
1749 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1750 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1751 wxPyEndBlockThreads(blocked);
1752 if (! found)
1753 wxTimer::Notify();
1754 }
1755 void wxPyTimer::base_Notify() {
1756 wxTimer::Notify();
1757 }
1758
1759
1760
1761 SWIGINTERN PyObject *
1762 SWIG_FromCharPtr(const char* cptr)
1763 {
1764 if (cptr) {
1765 size_t size = strlen(cptr);
1766 if (size > INT_MAX) {
1767 return SWIG_NewPointerObj((char*)(cptr),
1768 SWIG_TypeQuery("char *"), 0);
1769 } else {
1770 if (size != 0) {
1771 return PyString_FromStringAndSize(cptr, size);
1772 } else {
1773 return PyString_FromString(cptr);
1774 }
1775 }
1776 }
1777 Py_INCREF(Py_None);
1778 return Py_None;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_CheckUnsignedLongInRange(unsigned long value,
1784 unsigned long max_value,
1785 const char *errmsg)
1786 {
1787 if (value > max_value) {
1788 if (errmsg) {
1789 PyErr_Format(PyExc_OverflowError,
1790 "value %lu is greater than '%s' minimum %lu",
1791 value, errmsg, max_value);
1792 }
1793 return 0;
1794 }
1795 return 1;
1796 }
1797
1798
1799 #if UINT_MAX != ULONG_MAX
1800 SWIGINTERN int
1801 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1802 {
1803 const char* errmsg = val ? "unsigned int" : (char*)0;
1804 unsigned long v;
1805 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1806 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1807 if (val) *val = (unsigned int)(v);
1808 return 1;
1809 }
1810 } else {
1811 PyErr_Clear();
1812 }
1813 if (val) {
1814 SWIG_type_error(errmsg, obj);
1815 }
1816 return 0;
1817 }
1818 #else
1819 SWIGINTERNSHORT unsigned int
1820 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1821 {
1822 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1823 }
1824 #endif
1825
1826
1827 SWIGINTERNSHORT unsigned int
1828 SWIG_As_unsigned_SS_int(PyObject* obj)
1829 {
1830 unsigned int v;
1831 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1832 /*
1833 this is needed to make valgrind/purify happier.
1834 */
1835 memset((void*)&v, 0, sizeof(unsigned int));
1836 }
1837 return v;
1838 }
1839
1840
1841 SWIGINTERNSHORT int
1842 SWIG_Check_unsigned_SS_int(PyObject* obj)
1843 {
1844 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1845 }
1846
1847 static wxString Log_TimeStamp(){
1848 wxString msg;
1849 wxLog::TimeStamp(&msg);
1850 return msg;
1851 }
1852 static void wxLog_Destroy(wxLog *self){ delete self; }
1853 // Make somce wrappers that double any % signs so they are 'escaped'
1854 void wxPyLogFatalError(const wxString& msg)
1855 {
1856 wxString m(msg);
1857 m.Replace(wxT("%"), wxT("%%"));
1858 wxLogFatalError(m);
1859 }
1860
1861 void wxPyLogError(const wxString& msg)
1862 {
1863 wxString m(msg);
1864 m.Replace(wxT("%"), wxT("%%"));
1865 wxLogError(m);
1866 }
1867
1868 void wxPyLogWarning(const wxString& msg)
1869 {
1870 wxString m(msg);
1871 m.Replace(wxT("%"), wxT("%%"));
1872 wxLogWarning(m);
1873 }
1874
1875 void wxPyLogMessage(const wxString& msg)
1876 {
1877 wxString m(msg);
1878 m.Replace(wxT("%"), wxT("%%"));
1879 wxLogMessage(m);
1880 }
1881
1882 void wxPyLogInfo(const wxString& msg)
1883 {
1884 wxString m(msg);
1885 m.Replace(wxT("%"), wxT("%%"));
1886 wxLogInfo(m);
1887 }
1888
1889 void wxPyLogDebug(const wxString& msg)
1890 {
1891 wxString m(msg);
1892 m.Replace(wxT("%"), wxT("%%"));
1893 wxLogDebug(m);
1894 }
1895
1896 void wxPyLogVerbose(const wxString& msg)
1897 {
1898 wxString m(msg);
1899 m.Replace(wxT("%"), wxT("%%"));
1900 wxLogVerbose(m);
1901 }
1902
1903 void wxPyLogStatus(const wxString& msg)
1904 {
1905 wxString m(msg);
1906 m.Replace(wxT("%"), wxT("%%"));
1907 wxLogStatus(m);
1908 }
1909
1910 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1911 {
1912 wxString m(msg);
1913 m.Replace(wxT("%"), wxT("%%"));
1914 wxLogStatus(pFrame, m);
1915 }
1916
1917 void wxPyLogSysError(const wxString& msg)
1918 {
1919 wxString m(msg);
1920 m.Replace(wxT("%"), wxT("%%"));
1921 wxLogSysError(m);
1922 }
1923
1924 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1925 {
1926 wxString m(msg);
1927 m.Replace(wxT("%"), wxT("%%"));
1928 wxLogGeneric(level, m);
1929 }
1930
1931 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1932 {
1933 wxString m(msg);
1934 m.Replace(wxT("%"), wxT("%%"));
1935 wxLogTrace(mask, m);
1936 }
1937
1938 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1939 {
1940 wxString m(msg);
1941 m.Replace(wxT("%"), wxT("%%"));
1942 wxLogTrace(mask, m);
1943 }
1944
1945
1946
1947 // A wxLog class that can be derived from in wxPython
1948 class wxPyLog : public wxLog {
1949 public:
1950 wxPyLog() : wxLog() {}
1951
1952 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1953 bool found;
1954 bool blocked = wxPyBeginBlockThreads();
1955 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1956 PyObject* s = wx2PyString(szString);
1957 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1958 Py_DECREF(s);
1959 }
1960 wxPyEndBlockThreads(blocked);
1961 if (! found)
1962 wxLog::DoLog(level, szString, t);
1963 }
1964
1965 virtual void DoLogString(const wxChar *szString, time_t t) {
1966 bool found;
1967 bool blocked = wxPyBeginBlockThreads();
1968 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1969 PyObject* s = wx2PyString(szString);
1970 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1971 Py_DECREF(s);
1972 }
1973 wxPyEndBlockThreads(blocked);
1974 if (! found)
1975 wxLog::DoLogString(szString, t);
1976 }
1977
1978 PYPRIVATE;
1979 };
1980
1981
1982
1983
1984 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1985
1986
1987 #include <wx/joystick.h>
1988
1989
1990 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1991 // A C++ stub class for wxJoystick for platforms that don't have it.
1992 class wxJoystick : public wxObject {
1993 public:
1994 wxJoystick(int joystick = wxJOYSTICK1) {
1995 bool blocked = wxPyBeginBlockThreads();
1996 PyErr_SetString(PyExc_NotImplementedError,
1997 "wxJoystick is not available on this platform.");
1998 wxPyEndBlockThreads(blocked);
1999 }
2000 wxPoint GetPosition() { return wxPoint(-1,-1); }
2001 int GetZPosition() { return -1; }
2002 int GetButtonState() { return -1; }
2003 int GetPOVPosition() { return -1; }
2004 int GetPOVCTSPosition() { return -1; }
2005 int GetRudderPosition() { return -1; }
2006 int GetUPosition() { return -1; }
2007 int GetVPosition() { return -1; }
2008 int GetMovementThreshold() { return -1; }
2009 void SetMovementThreshold(int threshold) {}
2010
2011 bool IsOk(void) { return false; }
2012 int GetNumberJoysticks() { return -1; }
2013 int GetManufacturerId() { return -1; }
2014 int GetProductId() { return -1; }
2015 wxString GetProductName() { return wxEmptyString; }
2016 int GetXMin() { return -1; }
2017 int GetYMin() { return -1; }
2018 int GetZMin() { return -1; }
2019 int GetXMax() { return -1; }
2020 int GetYMax() { return -1; }
2021 int GetZMax() { return -1; }
2022 int GetNumberButtons() { return -1; }
2023 int GetNumberAxes() { return -1; }
2024 int GetMaxButtons() { return -1; }
2025 int GetMaxAxes() { return -1; }
2026 int GetPollingMin() { return -1; }
2027 int GetPollingMax() { return -1; }
2028 int GetRudderMin() { return -1; }
2029 int GetRudderMax() { return -1; }
2030 int GetUMin() { return -1; }
2031 int GetUMax() { return -1; }
2032 int GetVMin() { return -1; }
2033 int GetVMax() { return -1; }
2034
2035 bool HasRudder() { return false; }
2036 bool HasZ() { return false; }
2037 bool HasU() { return false; }
2038 bool HasV() { return false; }
2039 bool HasPOV() { return false; }
2040 bool HasPOV4Dir() { return false; }
2041 bool HasPOVCTS() { return false; }
2042
2043 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2044 bool ReleaseCapture() { return false; }
2045 };
2046 #endif
2047
2048
2049 #include <wx/sound.h>
2050
2051
2052 #if !wxUSE_SOUND
2053 // A C++ stub class for wxWave for platforms that don't have it.
2054 class wxSound : public wxObject
2055 {
2056 public:
2057 wxSound() {
2058 bool blocked = wxPyBeginBlockThreads();
2059 PyErr_SetString(PyExc_NotImplementedError,
2060 "wxSound is not available on this platform.");
2061 wxPyEndBlockThreads(blocked);
2062 }
2063 wxSound(const wxString&/*, bool*/) {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(int, const wxByte*) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075
2076 ~wxSound() {};
2077
2078 bool Create(const wxString&/*, bool*/) { return false; }
2079 bool Create(int, const wxByte*) { return false; };
2080 bool IsOk() { return false; };
2081 bool Play(unsigned) const { return false; }
2082 static bool Play(const wxString&, unsigned) { return false; }
2083 static void Stop() {}
2084 };
2085
2086 #endif
2087
2088 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2089 if (fileName.Length() == 0)
2090 return new wxSound;
2091 else
2092 return new wxSound(fileName);
2093 }
2094 static wxSound *new_wxSound(PyObject *data){
2095 unsigned char* buffer; int size;
2096 wxSound *sound = NULL;
2097
2098 bool blocked = wxPyBeginBlockThreads();
2099 if (!PyArg_Parse(data, "t#", &buffer, &size))
2100 goto done;
2101 sound = new wxSound(size, buffer);
2102 done:
2103 wxPyEndBlockThreads(blocked);
2104 return sound;
2105 }
2106 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2107 #ifndef __WXMAC__
2108 unsigned char* buffer;
2109 int size;
2110 bool rv = false;
2111
2112 bool blocked = wxPyBeginBlockThreads();
2113 if (!PyArg_Parse(data, "t#", &buffer, &size))
2114 goto done;
2115 rv = self->Create(size, buffer);
2116 done:
2117 wxPyEndBlockThreads(blocked);
2118 return rv;
2119 #else
2120 bool blocked = wxPyBeginBlockThreads();
2121 PyErr_SetString(PyExc_NotImplementedError,
2122 "Create from data is not available on this platform.");
2123 wxPyEndBlockThreads(blocked);
2124 return false;
2125 #endif
2126 }
2127
2128 #include <wx/mimetype.h>
2129
2130 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2131 wxString str;
2132 if (self->GetMimeType(&str))
2133 return wx2PyString(str);
2134 else
2135 RETURN_NONE();
2136 }
2137 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2138 wxArrayString arr;
2139 if (self->GetMimeTypes(arr))
2140 return wxArrayString2PyList_helper(arr);
2141 else
2142 RETURN_NONE();
2143 }
2144 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2145 wxArrayString arr;
2146 if (self->GetExtensions(arr))
2147 return wxArrayString2PyList_helper(arr);
2148 else
2149 RETURN_NONE();
2150 }
2151 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2152 wxIconLocation loc;
2153 if (self->GetIcon(&loc))
2154 return new wxIcon(loc);
2155 else
2156 return NULL;
2157 }
2158 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2159 wxIconLocation loc;
2160 if (self->GetIcon(&loc)) {
2161 wxString iconFile = loc.GetFileName();
2162 int iconIndex = -1;
2163
2164
2165
2166 // Make a tuple and put the values in it
2167 bool blocked = wxPyBeginBlockThreads();
2168 PyObject* tuple = PyTuple_New(3);
2169 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2170 wxT("wxIcon"), true));
2171 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2172 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2173 wxPyEndBlockThreads(blocked);
2174 return tuple;
2175 }
2176 else
2177 RETURN_NONE();
2178 }
2179 static PyObject *wxFileType_GetDescription(wxFileType *self){
2180 wxString str;
2181 if (self->GetDescription(&str))
2182 return wx2PyString(str);
2183 else
2184 RETURN_NONE();
2185 }
2186 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2187 wxString str;
2188 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2189 return wx2PyString(str);
2190 else
2191 RETURN_NONE();
2192 }
2193 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2194 wxString str;
2195 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2196 return wx2PyString(str);
2197 else
2198 RETURN_NONE();
2199 }
2200 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2201 wxArrayString verbs;
2202 wxArrayString commands;
2203 if (self->GetAllCommands(&verbs, &commands,
2204 wxFileType::MessageParameters(filename, mimetype))) {
2205 bool blocked = wxPyBeginBlockThreads();
2206 PyObject* tuple = PyTuple_New(2);
2207 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2208 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2209 wxPyEndBlockThreads(blocked);
2210 return tuple;
2211 }
2212 else
2213 RETURN_NONE();
2214 }
2215 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2216 return wxFileType::ExpandCommand(command,
2217 wxFileType::MessageParameters(filename, mimetype));
2218 }
2219 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2220 wxArrayString arr;
2221 self->EnumAllFileTypes(arr);
2222 return wxArrayString2PyList_helper(arr);
2223 }
2224
2225 #include <wx/artprov.h>
2226
2227 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2228 static const wxString wxPyART_MENU(wxART_MENU);
2229 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2230 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2231 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2232 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2233 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2234 static const wxString wxPyART_OTHER(wxART_OTHER);
2235 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2236 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2237 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2238 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2239 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2240 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2241 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2242 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2243 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2244 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2245 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2246 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2247 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2248 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2249 static const wxString wxPyART_PRINT(wxART_PRINT);
2250 static const wxString wxPyART_HELP(wxART_HELP);
2251 static const wxString wxPyART_TIP(wxART_TIP);
2252 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2253 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2254 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2255 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2256 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2257 static const wxString wxPyART_CDROM(wxART_CDROM);
2258 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2259 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2260 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2261 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2262 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2263 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2264 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2265 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2266 static const wxString wxPyART_ERROR(wxART_ERROR);
2267 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2268 static const wxString wxPyART_WARNING(wxART_WARNING);
2269 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2270 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2271 // Python aware wxArtProvider
2272 class wxPyArtProvider : public wxArtProvider {
2273 public:
2274
2275 virtual wxBitmap CreateBitmap(const wxArtID& id,
2276 const wxArtClient& client,
2277 const wxSize& size) {
2278 wxBitmap rval = wxNullBitmap;
2279 bool blocked = wxPyBeginBlockThreads();
2280 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2281 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2282 PyObject* ro;
2283 wxBitmap* ptr;
2284 PyObject* s1, *s2;
2285 s1 = wx2PyString(id);
2286 s2 = wx2PyString(client);
2287 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2288 Py_DECREF(so);
2289 Py_DECREF(s1);
2290 Py_DECREF(s2);
2291 if (ro) {
2292 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2293 rval = *ptr;
2294 Py_DECREF(ro);
2295 }
2296 }
2297 wxPyEndBlockThreads(blocked);
2298 return rval;
2299 }
2300
2301 PYPRIVATE;
2302 };
2303
2304 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2305
2306
2307
2308 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2309 PyObject* ret = PyTuple_New(3);
2310 if (ret) {
2311 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2312 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2313 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2314 }
2315 return ret;
2316 }
2317
2318 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2319 bool cont;
2320 long index = 0;
2321 wxString value;
2322
2323 cont = self->GetFirstGroup(value, index);
2324 return __EnumerationHelper(cont, value, index);
2325 }
2326 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2327 bool cont;
2328 wxString value;
2329
2330 cont = self->GetNextGroup(value, index);
2331 return __EnumerationHelper(cont, value, index);
2332 }
2333 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2334 bool cont;
2335 long index = 0;
2336 wxString value;
2337
2338 cont = self->GetFirstEntry(value, index);
2339 return __EnumerationHelper(cont, value, index);
2340 }
2341 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2342 bool cont;
2343 wxString value;
2344
2345 cont = self->GetNextEntry(value, index);
2346 return __EnumerationHelper(cont, value, index);
2347 }
2348 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2349 long rv;
2350 self->Read(key, &rv, defaultVal);
2351 return rv;
2352 }
2353
2354 SWIGINTERN int
2355 SWIG_AsVal_double(PyObject *obj, double* val)
2356 {
2357 if (PyNumber_Check(obj)) {
2358 if (val) *val = PyFloat_AsDouble(obj);
2359 return 1;
2360 }
2361 else {
2362 SWIG_type_error("number", obj);
2363 }
2364 return 0;
2365 }
2366
2367
2368 SWIGINTERNSHORT double
2369 SWIG_As_double(PyObject* obj)
2370 {
2371 double v;
2372 if (!SWIG_AsVal_double(obj, &v)) {
2373 /*
2374 this is needed to make valgrind/purify happier.
2375 */
2376 memset((void*)&v, 0, sizeof(double));
2377 }
2378 return v;
2379 }
2380
2381
2382 SWIGINTERNSHORT int
2383 SWIG_Check_double(PyObject* obj)
2384 {
2385 return SWIG_AsVal_double(obj, (double*)0);
2386 }
2387
2388 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2389 double rv;
2390 self->Read(key, &rv, defaultVal);
2391 return rv;
2392 }
2393
2394 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2395 #define SWIG_From_double PyFloat_FromDouble
2396 /*@@*/
2397
2398 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2399 bool rv;
2400 self->Read(key, &rv, defaultVal);
2401 return rv;
2402 }
2403
2404 #include <wx/datetime.h>
2405
2406 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2407 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2408
2409 #define LOCAL_TZ wxDateTime::Local
2410
2411
2412 #if UINT_MAX < LONG_MAX
2413 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2414 #define SWIG_From_unsigned_SS_int SWIG_From_long
2415 /*@@*/
2416 #else
2417 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2418 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2419 /*@@*/
2420 #endif
2421
2422 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2423 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2424 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2425 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2426 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2427 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2428 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2429 return (*self < *other);
2430 }
2431 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2432 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2433 return (*self <= *other);
2434 }
2435 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2436 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2437 return (*self > *other);
2438 }
2439 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2440 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2441 return (*self >= *other);
2442 }
2443 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2444 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2445 return (*self == *other);
2446 }
2447 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2448 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2449 return (*self != *other);
2450 }
2451 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2452 const wxChar* rv;
2453 const wxChar* _date = date;
2454 rv = self->ParseRfc822Date(_date);
2455 if (rv == NULL) return -1;
2456 return rv - _date;
2457 }
2458 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2459 const wxChar* rv;
2460 const wxChar* _date = date;
2461 rv = self->ParseFormat(_date, format, dateDef);
2462 if (rv == NULL) return -1;
2463 return rv - _date;
2464 }
2465 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2466 const wxChar* rv;
2467 const wxChar* _datetime = datetime;
2468 rv = self->ParseDateTime(_datetime);
2469 if (rv == NULL) return -1;
2470 return rv - _datetime;
2471 }
2472 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2473 const wxChar* rv;
2474 const wxChar* _date = date;
2475 rv = self->ParseDate(_date);
2476 if (rv == NULL) return -1;
2477 return rv - _date;
2478 }
2479 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2480 const wxChar* rv;
2481 const wxChar* _time = time;
2482 rv = self->ParseTime(_time);
2483 if (rv == NULL) return -1;
2484 return rv - _time;
2485 }
2486 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2487 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2488 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2489 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2490 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2491 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2492 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2493 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2494 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2495 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2496 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2497 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2498 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2499 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2500 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2501 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2502
2503 #include <wx/dataobj.h>
2504
2505 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2506 size_t count = self->GetFormatCount(dir);
2507 wxDataFormat* formats = new wxDataFormat[count];
2508 self->GetAllFormats(formats, dir);
2509
2510 bool blocked = wxPyBeginBlockThreads();
2511 PyObject* list = PyList_New(count);
2512 for (size_t i=0; i<count; i++) {
2513 wxDataFormat* format = new wxDataFormat(formats[i]);
2514 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2515 PyList_Append(list, obj);
2516 Py_DECREF(obj);
2517 }
2518 wxPyEndBlockThreads(blocked);
2519 delete [] formats;
2520 return list;
2521 }
2522 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2523 PyObject* rval = NULL;
2524 size_t size = self->GetDataSize(format);
2525 bool blocked = wxPyBeginBlockThreads();
2526 if (size) {
2527 char* buf = new char[size];
2528 if (self->GetDataHere(format, buf))
2529 rval = PyString_FromStringAndSize(buf, size);
2530 delete [] buf;
2531 }
2532 if (! rval) {
2533 rval = Py_None;
2534 Py_INCREF(rval);
2535 }
2536 wxPyEndBlockThreads(blocked);
2537 return rval;
2538 }
2539 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2540 bool rval;
2541 bool blocked = wxPyBeginBlockThreads();
2542 if (PyString_Check(data)) {
2543 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2544 }
2545 else {
2546 // raise a TypeError if not a string
2547 PyErr_SetString(PyExc_TypeError, "String expected.");
2548 rval = false;
2549 }
2550 wxPyEndBlockThreads(blocked);
2551 return rval;
2552 }
2553 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2554 PyObject* rval = NULL;
2555 size_t size = self->GetDataSize();
2556 bool blocked = wxPyBeginBlockThreads();
2557 if (size) {
2558 char* buf = new char[size];
2559 if (self->GetDataHere(buf))
2560 rval = PyString_FromStringAndSize(buf, size);
2561 delete [] buf;
2562 }
2563 if (! rval) {
2564 rval = Py_None;
2565 Py_INCREF(rval);
2566 }
2567 wxPyEndBlockThreads(blocked);
2568 return rval;
2569 }
2570 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2571 bool rval;
2572 bool blocked = wxPyBeginBlockThreads();
2573 if (PyString_Check(data)) {
2574 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2575 }
2576 else {
2577 // raise a TypeError if not a string
2578 PyErr_SetString(PyExc_TypeError, "String expected.");
2579 rval = false;
2580 }
2581 wxPyEndBlockThreads(blocked);
2582 return rval;
2583 }
2584 // Create a new class for wxPython to use
2585 class wxPyDataObjectSimple : public wxDataObjectSimple {
2586 public:
2587 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2588 : wxDataObjectSimple(format) {}
2589
2590 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2591 bool GetDataHere(void *buf) const;
2592 bool SetData(size_t len, const void *buf) const;
2593 PYPRIVATE;
2594 };
2595
2596 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2597
2598 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2599 // We need to get the data for this object and write it to buf. I think
2600 // the best way to do this for wxPython is to have the Python method
2601 // return either a string or None and then act appropriately with the
2602 // C++ version.
2603
2604 bool rval = false;
2605 bool blocked = wxPyBeginBlockThreads();
2606 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2607 PyObject* ro;
2608 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2609 if (ro) {
2610 rval = (ro != Py_None && PyString_Check(ro));
2611 if (rval)
2612 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2613 Py_DECREF(ro);
2614 }
2615 }
2616 wxPyEndBlockThreads(blocked);
2617 return rval;
2618 }
2619
2620 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2621 // For this one we simply need to make a string from buf and len
2622 // and send it to the Python method.
2623 bool rval = false;
2624 bool blocked = wxPyBeginBlockThreads();
2625 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2626 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2627 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2628 Py_DECREF(data);
2629 }
2630 wxPyEndBlockThreads(blocked);
2631 return rval;
2632 }
2633
2634 // Create a new class for wxPython to use
2635 class wxPyTextDataObject : public wxTextDataObject {
2636 public:
2637 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2638 : wxTextDataObject(text) {}
2639
2640 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2641 DEC_PYCALLBACK_STRING__const(GetText);
2642 DEC_PYCALLBACK__STRING(SetText);
2643 PYPRIVATE;
2644 };
2645
2646 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2647 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2648 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2649
2650
2651 // Create a new class for wxPython to use
2652 class wxPyBitmapDataObject : public wxBitmapDataObject {
2653 public:
2654 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2655 : wxBitmapDataObject(bitmap) {}
2656
2657 wxBitmap GetBitmap() const;
2658 void SetBitmap(const wxBitmap& bitmap);
2659 PYPRIVATE;
2660 };
2661
2662 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2663 wxBitmap* rval = &wxNullBitmap;
2664 bool blocked = wxPyBeginBlockThreads();
2665 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2666 PyObject* ro;
2667 wxBitmap* ptr;
2668 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2669 if (ro) {
2670 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2671 rval = ptr;
2672 Py_DECREF(ro);
2673 }
2674 }
2675 wxPyEndBlockThreads(blocked);
2676 return *rval;
2677 }
2678
2679 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2680 bool blocked = wxPyBeginBlockThreads();
2681 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2682 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2683 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2684 Py_DECREF(bo);
2685 }
2686 wxPyEndBlockThreads(blocked);
2687 }
2688
2689 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2690 return new wxCustomDataObject(wxDataFormat(formatName));
2691 }
2692 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2693 bool rval;
2694 bool blocked = wxPyBeginBlockThreads();
2695 if (PyString_Check(data)) {
2696 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2697 }
2698 else {
2699 // raise a TypeError if not a string
2700 PyErr_SetString(PyExc_TypeError, "String expected.");
2701 rval = false;
2702 }
2703 wxPyEndBlockThreads(blocked);
2704 return rval;
2705 }
2706 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2707 PyObject* obj;
2708 bool blocked = wxPyBeginBlockThreads();
2709 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2710 wxPyEndBlockThreads(blocked);
2711 return obj;
2712 }
2713
2714 #include <wx/metafile.h>
2715
2716
2717 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2718
2719
2720 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2721 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2722 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2723 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2724 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2725
2726
2727 class wxPyTextDropTarget : public wxTextDropTarget {
2728 public:
2729 wxPyTextDropTarget() {}
2730
2731 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2732
2733 DEC_PYCALLBACK__(OnLeave);
2734 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2735 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2736 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2737 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2738
2739 PYPRIVATE;
2740 };
2741
2742 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2743 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2744 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2745 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2746 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2747 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2748
2749
2750
2751 class wxPyFileDropTarget : public wxFileDropTarget {
2752 public:
2753 wxPyFileDropTarget() {}
2754
2755 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2756
2757 DEC_PYCALLBACK__(OnLeave);
2758 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2759 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2760 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2761 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2762
2763 PYPRIVATE;
2764 };
2765
2766 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2767 const wxArrayString& filenames) {
2768 bool rval = false;
2769 bool blocked = wxPyBeginBlockThreads();
2770 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2771 PyObject* list = wxArrayString2PyList_helper(filenames);
2772 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2773 Py_DECREF(list);
2774 }
2775 wxPyEndBlockThreads(blocked);
2776 return rval;
2777 }
2778
2779
2780
2781 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2782 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2783 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2784 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2785 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2786
2787
2788
2789
2790 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2791
2792 #include <wx/display.h>
2793
2794 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2795 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2796
2797 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2798 #if !wxUSE_DISPLAY
2799 #include <wx/dynarray.h>
2800 #include <wx/vidmode.h>
2801
2802 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2803 #include "wx/arrimpl.cpp"
2804 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2805 const wxVideoMode wxDefaultVideoMode;
2806
2807 class wxDisplay
2808 {
2809 public:
2810 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2811 ~wxDisplay() {}
2812
2813 static size_t GetCount()
2814 { wxPyRaiseNotImplemented(); return 0; }
2815
2816 static int GetFromPoint(const wxPoint& pt)
2817 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2818 static int GetFromWindow(wxWindow *window)
2819 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2820
2821 virtual bool IsOk() const { return false; }
2822 virtual wxRect GetGeometry() const { wxRect r; return r; }
2823 virtual wxString GetName() const { return wxEmptyString; }
2824 bool IsPrimary() const { return false; }
2825
2826 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2827 { wxArrayVideoModes a; return a; }
2828
2829 virtual wxVideoMode GetCurrentMode() const
2830 { return wxDefaultVideoMode; }
2831
2832 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2833 { return false; }
2834
2835 void ResetMode() {}
2836 };
2837 #endif
2838
2839 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2840 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2841 PyObject* pyList = NULL;
2842 wxArrayVideoModes arr = self->GetModes(mode);
2843 bool blocked = wxPyBeginBlockThreads();
2844 pyList = PyList_New(0);
2845 for (int i=0; i < arr.GetCount(); i++) {
2846 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2847 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2848 PyList_Append(pyList, pyObj);
2849 Py_DECREF(pyObj);
2850 }
2851 wxPyEndBlockThreads(blocked);
2852 return pyList;
2853 }
2854
2855 #include <wx/stdpaths.h>
2856
2857 static wxStandardPaths *StandardPaths_Get(){
2858 return (wxStandardPaths*) &wxStandardPaths::Get();
2859 }
2860 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2861 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2862 #ifdef __cplusplus
2863 extern "C" {
2864 #endif
2865 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2866 PyObject *resultobj;
2867 wxSystemColour arg1 ;
2868 wxColour result;
2869 PyObject * obj0 = 0 ;
2870 char *kwnames[] = {
2871 (char *) "index", NULL
2872 };
2873
2874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2875 {
2876 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2877 if (SWIG_arg_fail(1)) SWIG_fail;
2878 }
2879 {
2880 if (!wxPyCheckForApp()) SWIG_fail;
2881 PyThreadState* __tstate = wxPyBeginAllowThreads();
2882 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2883
2884 wxPyEndAllowThreads(__tstate);
2885 if (PyErr_Occurred()) SWIG_fail;
2886 }
2887 {
2888 wxColour * resultptr;
2889 resultptr = new wxColour((wxColour &)(result));
2890 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2891 }
2892 return resultobj;
2893 fail:
2894 return NULL;
2895 }
2896
2897
2898 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2899 PyObject *resultobj;
2900 wxSystemFont arg1 ;
2901 wxFont result;
2902 PyObject * obj0 = 0 ;
2903 char *kwnames[] = {
2904 (char *) "index", NULL
2905 };
2906
2907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2908 {
2909 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2910 if (SWIG_arg_fail(1)) SWIG_fail;
2911 }
2912 {
2913 if (!wxPyCheckForApp()) SWIG_fail;
2914 PyThreadState* __tstate = wxPyBeginAllowThreads();
2915 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2916
2917 wxPyEndAllowThreads(__tstate);
2918 if (PyErr_Occurred()) SWIG_fail;
2919 }
2920 {
2921 wxFont * resultptr;
2922 resultptr = new wxFont((wxFont &)(result));
2923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2924 }
2925 return resultobj;
2926 fail:
2927 return NULL;
2928 }
2929
2930
2931 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2932 PyObject *resultobj;
2933 wxSystemMetric arg1 ;
2934 int result;
2935 PyObject * obj0 = 0 ;
2936 char *kwnames[] = {
2937 (char *) "index", NULL
2938 };
2939
2940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2941 {
2942 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2943 if (SWIG_arg_fail(1)) SWIG_fail;
2944 }
2945 {
2946 if (!wxPyCheckForApp()) SWIG_fail;
2947 PyThreadState* __tstate = wxPyBeginAllowThreads();
2948 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2949
2950 wxPyEndAllowThreads(__tstate);
2951 if (PyErr_Occurred()) SWIG_fail;
2952 }
2953 {
2954 resultobj = SWIG_From_int((int)(result));
2955 }
2956 return resultobj;
2957 fail:
2958 return NULL;
2959 }
2960
2961
2962 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2963 PyObject *resultobj;
2964 wxSystemFeature arg1 ;
2965 bool result;
2966 PyObject * obj0 = 0 ;
2967 char *kwnames[] = {
2968 (char *) "index", NULL
2969 };
2970
2971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2972 {
2973 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2974 if (SWIG_arg_fail(1)) SWIG_fail;
2975 }
2976 {
2977 if (!wxPyCheckForApp()) SWIG_fail;
2978 PyThreadState* __tstate = wxPyBeginAllowThreads();
2979 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2980
2981 wxPyEndAllowThreads(__tstate);
2982 if (PyErr_Occurred()) SWIG_fail;
2983 }
2984 {
2985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2986 }
2987 return resultobj;
2988 fail:
2989 return NULL;
2990 }
2991
2992
2993 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
2994 PyObject *resultobj;
2995 wxSystemScreenType result;
2996 char *kwnames[] = {
2997 NULL
2998 };
2999
3000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3001 {
3002 if (!wxPyCheckForApp()) SWIG_fail;
3003 PyThreadState* __tstate = wxPyBeginAllowThreads();
3004 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3005
3006 wxPyEndAllowThreads(__tstate);
3007 if (PyErr_Occurred()) SWIG_fail;
3008 }
3009 resultobj = SWIG_From_int((result));
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxSystemScreenType arg1 ;
3019 PyObject * obj0 = 0 ;
3020 char *kwnames[] = {
3021 (char *) "screen", NULL
3022 };
3023
3024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3025 {
3026 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3027 if (SWIG_arg_fail(1)) SWIG_fail;
3028 }
3029 {
3030 if (!wxPyCheckForApp()) SWIG_fail;
3031 PyThreadState* __tstate = wxPyBeginAllowThreads();
3032 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3033
3034 wxPyEndAllowThreads(__tstate);
3035 if (PyErr_Occurred()) SWIG_fail;
3036 }
3037 Py_INCREF(Py_None); resultobj = Py_None;
3038 return resultobj;
3039 fail:
3040 return NULL;
3041 }
3042
3043
3044 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3045 PyObject *obj;
3046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3047 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3048 Py_INCREF(obj);
3049 return Py_BuildValue((char *)"");
3050 }
3051 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3052 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3053 return 1;
3054 }
3055
3056
3057 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3058 PyObject *pyobj;
3059
3060 {
3061 #if wxUSE_UNICODE
3062 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3063 #else
3064 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3065 #endif
3066 }
3067 return pyobj;
3068 }
3069
3070
3071 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3072 PyObject *resultobj;
3073 wxSystemOptions *result;
3074 char *kwnames[] = {
3075 NULL
3076 };
3077
3078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3079 {
3080 PyThreadState* __tstate = wxPyBeginAllowThreads();
3081 result = (wxSystemOptions *)new wxSystemOptions();
3082
3083 wxPyEndAllowThreads(__tstate);
3084 if (PyErr_Occurred()) SWIG_fail;
3085 }
3086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3087 return resultobj;
3088 fail:
3089 return NULL;
3090 }
3091
3092
3093 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3094 PyObject *resultobj;
3095 wxString *arg1 = 0 ;
3096 wxString *arg2 = 0 ;
3097 bool temp1 = false ;
3098 bool temp2 = false ;
3099 PyObject * obj0 = 0 ;
3100 PyObject * obj1 = 0 ;
3101 char *kwnames[] = {
3102 (char *) "name",(char *) "value", NULL
3103 };
3104
3105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3106 {
3107 arg1 = wxString_in_helper(obj0);
3108 if (arg1 == NULL) SWIG_fail;
3109 temp1 = true;
3110 }
3111 {
3112 arg2 = wxString_in_helper(obj1);
3113 if (arg2 == NULL) SWIG_fail;
3114 temp2 = true;
3115 }
3116 {
3117 PyThreadState* __tstate = wxPyBeginAllowThreads();
3118 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3119
3120 wxPyEndAllowThreads(__tstate);
3121 if (PyErr_Occurred()) SWIG_fail;
3122 }
3123 Py_INCREF(Py_None); resultobj = Py_None;
3124 {
3125 if (temp1)
3126 delete arg1;
3127 }
3128 {
3129 if (temp2)
3130 delete arg2;
3131 }
3132 return resultobj;
3133 fail:
3134 {
3135 if (temp1)
3136 delete arg1;
3137 }
3138 {
3139 if (temp2)
3140 delete arg2;
3141 }
3142 return NULL;
3143 }
3144
3145
3146 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3147 PyObject *resultobj;
3148 wxString *arg1 = 0 ;
3149 int arg2 ;
3150 bool temp1 = false ;
3151 PyObject * obj0 = 0 ;
3152 PyObject * obj1 = 0 ;
3153 char *kwnames[] = {
3154 (char *) "name",(char *) "value", NULL
3155 };
3156
3157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3158 {
3159 arg1 = wxString_in_helper(obj0);
3160 if (arg1 == NULL) SWIG_fail;
3161 temp1 = true;
3162 }
3163 {
3164 arg2 = (int)(SWIG_As_int(obj1));
3165 if (SWIG_arg_fail(2)) SWIG_fail;
3166 }
3167 {
3168 PyThreadState* __tstate = wxPyBeginAllowThreads();
3169 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3170
3171 wxPyEndAllowThreads(__tstate);
3172 if (PyErr_Occurred()) SWIG_fail;
3173 }
3174 Py_INCREF(Py_None); resultobj = Py_None;
3175 {
3176 if (temp1)
3177 delete arg1;
3178 }
3179 return resultobj;
3180 fail:
3181 {
3182 if (temp1)
3183 delete arg1;
3184 }
3185 return NULL;
3186 }
3187
3188
3189 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3190 PyObject *resultobj;
3191 wxString *arg1 = 0 ;
3192 wxString result;
3193 bool temp1 = false ;
3194 PyObject * obj0 = 0 ;
3195 char *kwnames[] = {
3196 (char *) "name", NULL
3197 };
3198
3199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3200 {
3201 arg1 = wxString_in_helper(obj0);
3202 if (arg1 == NULL) SWIG_fail;
3203 temp1 = true;
3204 }
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 {
3213 #if wxUSE_UNICODE
3214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3215 #else
3216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3217 #endif
3218 }
3219 {
3220 if (temp1)
3221 delete arg1;
3222 }
3223 return resultobj;
3224 fail:
3225 {
3226 if (temp1)
3227 delete arg1;
3228 }
3229 return NULL;
3230 }
3231
3232
3233 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3234 PyObject *resultobj;
3235 wxString *arg1 = 0 ;
3236 int result;
3237 bool temp1 = false ;
3238 PyObject * obj0 = 0 ;
3239 char *kwnames[] = {
3240 (char *) "name", NULL
3241 };
3242
3243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3244 {
3245 arg1 = wxString_in_helper(obj0);
3246 if (arg1 == NULL) SWIG_fail;
3247 temp1 = true;
3248 }
3249 {
3250 PyThreadState* __tstate = wxPyBeginAllowThreads();
3251 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3252
3253 wxPyEndAllowThreads(__tstate);
3254 if (PyErr_Occurred()) SWIG_fail;
3255 }
3256 {
3257 resultobj = SWIG_From_int((int)(result));
3258 }
3259 {
3260 if (temp1)
3261 delete arg1;
3262 }
3263 return resultobj;
3264 fail:
3265 {
3266 if (temp1)
3267 delete arg1;
3268 }
3269 return NULL;
3270 }
3271
3272
3273 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3274 PyObject *resultobj;
3275 wxString *arg1 = 0 ;
3276 bool result;
3277 bool temp1 = false ;
3278 PyObject * obj0 = 0 ;
3279 char *kwnames[] = {
3280 (char *) "name", NULL
3281 };
3282
3283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3284 {
3285 arg1 = wxString_in_helper(obj0);
3286 if (arg1 == NULL) SWIG_fail;
3287 temp1 = true;
3288 }
3289 {
3290 PyThreadState* __tstate = wxPyBeginAllowThreads();
3291 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3292
3293 wxPyEndAllowThreads(__tstate);
3294 if (PyErr_Occurred()) SWIG_fail;
3295 }
3296 {
3297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3298 }
3299 {
3300 if (temp1)
3301 delete arg1;
3302 }
3303 return resultobj;
3304 fail:
3305 {
3306 if (temp1)
3307 delete arg1;
3308 }
3309 return NULL;
3310 }
3311
3312
3313 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3314 PyObject *obj;
3315 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3316 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3317 Py_INCREF(obj);
3318 return Py_BuildValue((char *)"");
3319 }
3320 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3321 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3322 return 1;
3323 }
3324
3325
3326 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3327 PyObject *pyobj;
3328
3329 {
3330 #if wxUSE_UNICODE
3331 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3332 #else
3333 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3334 #endif
3335 }
3336 return pyobj;
3337 }
3338
3339
3340 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3341 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3342 return 1;
3343 }
3344
3345
3346 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3347 PyObject *pyobj;
3348
3349 {
3350 #if wxUSE_UNICODE
3351 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3352 #else
3353 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3354 #endif
3355 }
3356 return pyobj;
3357 }
3358
3359
3360 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3361 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3362 return 1;
3363 }
3364
3365
3366 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3367 PyObject *pyobj;
3368
3369 {
3370 #if wxUSE_UNICODE
3371 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3372 #else
3373 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3374 #endif
3375 }
3376 return pyobj;
3377 }
3378
3379
3380 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3381 PyObject *resultobj;
3382 long result;
3383 char *kwnames[] = {
3384 NULL
3385 };
3386
3387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3388 {
3389 PyThreadState* __tstate = wxPyBeginAllowThreads();
3390 result = (long)wxNewId();
3391
3392 wxPyEndAllowThreads(__tstate);
3393 if (PyErr_Occurred()) SWIG_fail;
3394 }
3395 {
3396 resultobj = SWIG_From_long((long)(result));
3397 }
3398 return resultobj;
3399 fail:
3400 return NULL;
3401 }
3402
3403
3404 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3405 PyObject *resultobj;
3406 long arg1 ;
3407 PyObject * obj0 = 0 ;
3408 char *kwnames[] = {
3409 (char *) "id", NULL
3410 };
3411
3412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3413 {
3414 arg1 = (long)(SWIG_As_long(obj0));
3415 if (SWIG_arg_fail(1)) SWIG_fail;
3416 }
3417 {
3418 PyThreadState* __tstate = wxPyBeginAllowThreads();
3419 wxRegisterId(arg1);
3420
3421 wxPyEndAllowThreads(__tstate);
3422 if (PyErr_Occurred()) SWIG_fail;
3423 }
3424 Py_INCREF(Py_None); resultobj = Py_None;
3425 return resultobj;
3426 fail:
3427 return NULL;
3428 }
3429
3430
3431 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3432 PyObject *resultobj;
3433 long result;
3434 char *kwnames[] = {
3435 NULL
3436 };
3437
3438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3439 {
3440 PyThreadState* __tstate = wxPyBeginAllowThreads();
3441 result = (long)wxGetCurrentId();
3442
3443 wxPyEndAllowThreads(__tstate);
3444 if (PyErr_Occurred()) SWIG_fail;
3445 }
3446 {
3447 resultobj = SWIG_From_long((long)(result));
3448 }
3449 return resultobj;
3450 fail:
3451 return NULL;
3452 }
3453
3454
3455 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj;
3457 int arg1 ;
3458 bool result;
3459 PyObject * obj0 = 0 ;
3460 char *kwnames[] = {
3461 (char *) "id", NULL
3462 };
3463
3464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3465 {
3466 arg1 = (int)(SWIG_As_int(obj0));
3467 if (SWIG_arg_fail(1)) SWIG_fail;
3468 }
3469 {
3470 PyThreadState* __tstate = wxPyBeginAllowThreads();
3471 result = (bool)wxIsStockID(arg1);
3472
3473 wxPyEndAllowThreads(__tstate);
3474 if (PyErr_Occurred()) SWIG_fail;
3475 }
3476 {
3477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3478 }
3479 return resultobj;
3480 fail:
3481 return NULL;
3482 }
3483
3484
3485 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3486 PyObject *resultobj;
3487 int arg1 ;
3488 wxString *arg2 = 0 ;
3489 bool result;
3490 bool temp2 = false ;
3491 PyObject * obj0 = 0 ;
3492 PyObject * obj1 = 0 ;
3493 char *kwnames[] = {
3494 (char *) "id",(char *) "label", NULL
3495 };
3496
3497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3498 {
3499 arg1 = (int)(SWIG_As_int(obj0));
3500 if (SWIG_arg_fail(1)) SWIG_fail;
3501 }
3502 {
3503 arg2 = wxString_in_helper(obj1);
3504 if (arg2 == NULL) SWIG_fail;
3505 temp2 = true;
3506 }
3507 {
3508 PyThreadState* __tstate = wxPyBeginAllowThreads();
3509 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3510
3511 wxPyEndAllowThreads(__tstate);
3512 if (PyErr_Occurred()) SWIG_fail;
3513 }
3514 {
3515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3516 }
3517 {
3518 if (temp2)
3519 delete arg2;
3520 }
3521 return resultobj;
3522 fail:
3523 {
3524 if (temp2)
3525 delete arg2;
3526 }
3527 return NULL;
3528 }
3529
3530
3531 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3532 PyObject *resultobj;
3533 int arg1 ;
3534 bool arg2 = (bool) true ;
3535 wxString arg3 = (wxString) wxPyEmptyString ;
3536 wxString result;
3537 PyObject * obj0 = 0 ;
3538 PyObject * obj1 = 0 ;
3539 PyObject * obj2 = 0 ;
3540 char *kwnames[] = {
3541 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3545 {
3546 arg1 = (int)(SWIG_As_int(obj0));
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 }
3549 if (obj1) {
3550 {
3551 arg2 = (bool)(SWIG_As_bool(obj1));
3552 if (SWIG_arg_fail(2)) SWIG_fail;
3553 }
3554 }
3555 if (obj2) {
3556 {
3557 wxString* sptr = wxString_in_helper(obj2);
3558 if (sptr == NULL) SWIG_fail;
3559 arg3 = *sptr;
3560 delete sptr;
3561 }
3562 }
3563 {
3564 PyThreadState* __tstate = wxPyBeginAllowThreads();
3565 result = wxGetStockLabel(arg1,arg2,arg3);
3566
3567 wxPyEndAllowThreads(__tstate);
3568 if (PyErr_Occurred()) SWIG_fail;
3569 }
3570 {
3571 #if wxUSE_UNICODE
3572 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3573 #else
3574 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3575 #endif
3576 }
3577 return resultobj;
3578 fail:
3579 return NULL;
3580 }
3581
3582
3583 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3584 PyObject *resultobj;
3585 char *kwnames[] = {
3586 NULL
3587 };
3588
3589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3590 {
3591 if (!wxPyCheckForApp()) SWIG_fail;
3592 PyThreadState* __tstate = wxPyBeginAllowThreads();
3593 wxBell();
3594
3595 wxPyEndAllowThreads(__tstate);
3596 if (PyErr_Occurred()) SWIG_fail;
3597 }
3598 Py_INCREF(Py_None); resultobj = Py_None;
3599 return resultobj;
3600 fail:
3601 return NULL;
3602 }
3603
3604
3605 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3606 PyObject *resultobj;
3607 char *kwnames[] = {
3608 NULL
3609 };
3610
3611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3612 {
3613 if (!wxPyCheckForApp()) SWIG_fail;
3614 PyThreadState* __tstate = wxPyBeginAllowThreads();
3615 wxEndBusyCursor();
3616
3617 wxPyEndAllowThreads(__tstate);
3618 if (PyErr_Occurred()) SWIG_fail;
3619 }
3620 Py_INCREF(Py_None); resultobj = Py_None;
3621 return resultobj;
3622 fail:
3623 return NULL;
3624 }
3625
3626
3627 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3628 PyObject *resultobj;
3629 bool arg1 = (bool) true ;
3630 long result;
3631 PyObject * obj0 = 0 ;
3632 char *kwnames[] = {
3633 (char *) "resetTimer", NULL
3634 };
3635
3636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3637 if (obj0) {
3638 {
3639 arg1 = (bool)(SWIG_As_bool(obj0));
3640 if (SWIG_arg_fail(1)) SWIG_fail;
3641 }
3642 }
3643 {
3644 PyThreadState* __tstate = wxPyBeginAllowThreads();
3645 result = (long)wxGetElapsedTime(arg1);
3646
3647 wxPyEndAllowThreads(__tstate);
3648 if (PyErr_Occurred()) SWIG_fail;
3649 }
3650 {
3651 resultobj = SWIG_From_long((long)(result));
3652 }
3653 return resultobj;
3654 fail:
3655 return NULL;
3656 }
3657
3658
3659 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3660 PyObject *resultobj;
3661 int *arg1 = (int *) 0 ;
3662 int *arg2 = (int *) 0 ;
3663 int temp1 ;
3664 int res1 = 0 ;
3665 int temp2 ;
3666 int res2 = 0 ;
3667 char *kwnames[] = {
3668 NULL
3669 };
3670
3671 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3672 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3674 {
3675 if (!wxPyCheckForApp()) SWIG_fail;
3676 PyThreadState* __tstate = wxPyBeginAllowThreads();
3677 wxGetMousePosition(arg1,arg2);
3678
3679 wxPyEndAllowThreads(__tstate);
3680 if (PyErr_Occurred()) SWIG_fail;
3681 }
3682 Py_INCREF(Py_None); resultobj = Py_None;
3683 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3684 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3685 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3686 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3687 return resultobj;
3688 fail:
3689 return NULL;
3690 }
3691
3692
3693 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3694 PyObject *resultobj;
3695 bool result;
3696 char *kwnames[] = {
3697 NULL
3698 };
3699
3700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3701 {
3702 PyThreadState* __tstate = wxPyBeginAllowThreads();
3703 result = (bool)wxIsBusy();
3704
3705 wxPyEndAllowThreads(__tstate);
3706 if (PyErr_Occurred()) SWIG_fail;
3707 }
3708 {
3709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3710 }
3711 return resultobj;
3712 fail:
3713 return NULL;
3714 }
3715
3716
3717 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3718 PyObject *resultobj;
3719 wxString result;
3720 char *kwnames[] = {
3721 NULL
3722 };
3723
3724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3725 {
3726 PyThreadState* __tstate = wxPyBeginAllowThreads();
3727 result = wxNow();
3728
3729 wxPyEndAllowThreads(__tstate);
3730 if (PyErr_Occurred()) SWIG_fail;
3731 }
3732 {
3733 #if wxUSE_UNICODE
3734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3735 #else
3736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3737 #endif
3738 }
3739 return resultobj;
3740 fail:
3741 return NULL;
3742 }
3743
3744
3745 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3746 PyObject *resultobj;
3747 wxString const &arg1_defvalue = wxPyEmptyString ;
3748 wxString *arg1 = (wxString *) &arg1_defvalue ;
3749 bool result;
3750 bool temp1 = false ;
3751 PyObject * obj0 = 0 ;
3752 char *kwnames[] = {
3753 (char *) "command", NULL
3754 };
3755
3756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3757 if (obj0) {
3758 {
3759 arg1 = wxString_in_helper(obj0);
3760 if (arg1 == NULL) SWIG_fail;
3761 temp1 = true;
3762 }
3763 }
3764 {
3765 PyThreadState* __tstate = wxPyBeginAllowThreads();
3766 result = (bool)wxShell((wxString const &)*arg1);
3767
3768 wxPyEndAllowThreads(__tstate);
3769 if (PyErr_Occurred()) SWIG_fail;
3770 }
3771 {
3772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3773 }
3774 {
3775 if (temp1)
3776 delete arg1;
3777 }
3778 return resultobj;
3779 fail:
3780 {
3781 if (temp1)
3782 delete arg1;
3783 }
3784 return NULL;
3785 }
3786
3787
3788 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj;
3790 char *kwnames[] = {
3791 NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3795 {
3796 PyThreadState* __tstate = wxPyBeginAllowThreads();
3797 wxStartTimer();
3798
3799 wxPyEndAllowThreads(__tstate);
3800 if (PyErr_Occurred()) SWIG_fail;
3801 }
3802 Py_INCREF(Py_None); resultobj = Py_None;
3803 return resultobj;
3804 fail:
3805 return NULL;
3806 }
3807
3808
3809 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3810 PyObject *resultobj;
3811 int *arg1 = (int *) 0 ;
3812 int *arg2 = (int *) 0 ;
3813 int result;
3814 int temp1 ;
3815 int res1 = 0 ;
3816 int temp2 ;
3817 int res2 = 0 ;
3818 char *kwnames[] = {
3819 NULL
3820 };
3821
3822 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3823 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (int)wxGetOsVersion(arg1,arg2);
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = SWIG_From_int((int)(result));
3834 }
3835 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3836 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3837 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3838 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj;
3847 wxString result;
3848 char *kwnames[] = {
3849 NULL
3850 };
3851
3852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3853 {
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 result = wxGetOsDescription();
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 {
3861 #if wxUSE_UNICODE
3862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3863 #else
3864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3865 #endif
3866 }
3867 return resultobj;
3868 fail:
3869 return NULL;
3870 }
3871
3872
3873 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3874 PyObject *resultobj;
3875 long result;
3876 char *kwnames[] = {
3877 NULL
3878 };
3879
3880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (long)wxGetFreeMemory();
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = SWIG_From_long((long)(result));
3890 }
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj;
3899 wxShutdownFlags arg1 ;
3900 bool result;
3901 PyObject * obj0 = 0 ;
3902 char *kwnames[] = {
3903 (char *) "wFlags", NULL
3904 };
3905
3906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3907 {
3908 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3909 if (SWIG_arg_fail(1)) SWIG_fail;
3910 }
3911 {
3912 if (!wxPyCheckForApp()) SWIG_fail;
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 {
3920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3921 }
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3929 PyObject *resultobj;
3930 int arg1 ;
3931 PyObject * obj0 = 0 ;
3932 char *kwnames[] = {
3933 (char *) "secs", NULL
3934 };
3935
3936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3937 {
3938 arg1 = (int)(SWIG_As_int(obj0));
3939 if (SWIG_arg_fail(1)) SWIG_fail;
3940 }
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 wxSleep(arg1);
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 Py_INCREF(Py_None); resultobj = Py_None;
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3956 PyObject *resultobj;
3957 unsigned long arg1 ;
3958 PyObject * obj0 = 0 ;
3959 char *kwnames[] = {
3960 (char *) "milliseconds", NULL
3961 };
3962
3963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3964 {
3965 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3966 if (SWIG_arg_fail(1)) SWIG_fail;
3967 }
3968 {
3969 PyThreadState* __tstate = wxPyBeginAllowThreads();
3970 wxMilliSleep(arg1);
3971
3972 wxPyEndAllowThreads(__tstate);
3973 if (PyErr_Occurred()) SWIG_fail;
3974 }
3975 Py_INCREF(Py_None); resultobj = Py_None;
3976 return resultobj;
3977 fail:
3978 return NULL;
3979 }
3980
3981
3982 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3983 PyObject *resultobj;
3984 unsigned long arg1 ;
3985 PyObject * obj0 = 0 ;
3986 char *kwnames[] = {
3987 (char *) "microseconds", NULL
3988 };
3989
3990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3991 {
3992 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3993 if (SWIG_arg_fail(1)) SWIG_fail;
3994 }
3995 {
3996 PyThreadState* __tstate = wxPyBeginAllowThreads();
3997 wxMicroSleep(arg1);
3998
3999 wxPyEndAllowThreads(__tstate);
4000 if (PyErr_Occurred()) SWIG_fail;
4001 }
4002 Py_INCREF(Py_None); resultobj = Py_None;
4003 return resultobj;
4004 fail:
4005 return NULL;
4006 }
4007
4008
4009 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4010 PyObject *resultobj;
4011 bool arg1 ;
4012 PyObject * obj0 = 0 ;
4013 char *kwnames[] = {
4014 (char *) "enable", NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4018 {
4019 arg1 = (bool)(SWIG_As_bool(obj0));
4020 if (SWIG_arg_fail(1)) SWIG_fail;
4021 }
4022 {
4023 PyThreadState* __tstate = wxPyBeginAllowThreads();
4024 wxEnableTopLevelWindows(arg1);
4025
4026 wxPyEndAllowThreads(__tstate);
4027 if (PyErr_Occurred()) SWIG_fail;
4028 }
4029 Py_INCREF(Py_None); resultobj = Py_None;
4030 return resultobj;
4031 fail:
4032 return NULL;
4033 }
4034
4035
4036 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4037 PyObject *resultobj;
4038 wxString *arg1 = 0 ;
4039 wxString result;
4040 bool temp1 = false ;
4041 PyObject * obj0 = 0 ;
4042 char *kwnames[] = {
4043 (char *) "in", NULL
4044 };
4045
4046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4047 {
4048 arg1 = wxString_in_helper(obj0);
4049 if (arg1 == NULL) SWIG_fail;
4050 temp1 = true;
4051 }
4052 {
4053 PyThreadState* __tstate = wxPyBeginAllowThreads();
4054 result = wxStripMenuCodes((wxString const &)*arg1);
4055
4056 wxPyEndAllowThreads(__tstate);
4057 if (PyErr_Occurred()) SWIG_fail;
4058 }
4059 {
4060 #if wxUSE_UNICODE
4061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4062 #else
4063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4064 #endif
4065 }
4066 {
4067 if (temp1)
4068 delete arg1;
4069 }
4070 return resultobj;
4071 fail:
4072 {
4073 if (temp1)
4074 delete arg1;
4075 }
4076 return NULL;
4077 }
4078
4079
4080 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4081 PyObject *resultobj;
4082 wxString result;
4083 char *kwnames[] = {
4084 NULL
4085 };
4086
4087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4088 {
4089 PyThreadState* __tstate = wxPyBeginAllowThreads();
4090 result = wxGetEmailAddress();
4091
4092 wxPyEndAllowThreads(__tstate);
4093 if (PyErr_Occurred()) SWIG_fail;
4094 }
4095 {
4096 #if wxUSE_UNICODE
4097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4098 #else
4099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4100 #endif
4101 }
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj;
4110 wxString result;
4111 char *kwnames[] = {
4112 NULL
4113 };
4114
4115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4116 {
4117 PyThreadState* __tstate = wxPyBeginAllowThreads();
4118 result = wxGetHostName();
4119
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 {
4124 #if wxUSE_UNICODE
4125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4126 #else
4127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4128 #endif
4129 }
4130 return resultobj;
4131 fail:
4132 return NULL;
4133 }
4134
4135
4136 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4137 PyObject *resultobj;
4138 wxString result;
4139 char *kwnames[] = {
4140 NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4144 {
4145 PyThreadState* __tstate = wxPyBeginAllowThreads();
4146 result = wxGetFullHostName();
4147
4148 wxPyEndAllowThreads(__tstate);
4149 if (PyErr_Occurred()) SWIG_fail;
4150 }
4151 {
4152 #if wxUSE_UNICODE
4153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4154 #else
4155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4156 #endif
4157 }
4158 return resultobj;
4159 fail:
4160 return NULL;
4161 }
4162
4163
4164 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4165 PyObject *resultobj;
4166 wxString result;
4167 char *kwnames[] = {
4168 NULL
4169 };
4170
4171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4172 {
4173 PyThreadState* __tstate = wxPyBeginAllowThreads();
4174 result = wxGetUserId();
4175
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 {
4180 #if wxUSE_UNICODE
4181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4182 #else
4183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4184 #endif
4185 }
4186 return resultobj;
4187 fail:
4188 return NULL;
4189 }
4190
4191
4192 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4193 PyObject *resultobj;
4194 wxString result;
4195 char *kwnames[] = {
4196 NULL
4197 };
4198
4199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4200 {
4201 PyThreadState* __tstate = wxPyBeginAllowThreads();
4202 result = wxGetUserName();
4203
4204 wxPyEndAllowThreads(__tstate);
4205 if (PyErr_Occurred()) SWIG_fail;
4206 }
4207 {
4208 #if wxUSE_UNICODE
4209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4210 #else
4211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4212 #endif
4213 }
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj;
4222 wxString result;
4223 char *kwnames[] = {
4224 NULL
4225 };
4226
4227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4228 {
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = wxGetHomeDir();
4231
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 #if wxUSE_UNICODE
4237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4238 #else
4239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4240 #endif
4241 }
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj;
4250 wxString const &arg1_defvalue = wxPyEmptyString ;
4251 wxString *arg1 = (wxString *) &arg1_defvalue ;
4252 wxString result;
4253 bool temp1 = false ;
4254 PyObject * obj0 = 0 ;
4255 char *kwnames[] = {
4256 (char *) "user", NULL
4257 };
4258
4259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4260 if (obj0) {
4261 {
4262 arg1 = wxString_in_helper(obj0);
4263 if (arg1 == NULL) SWIG_fail;
4264 temp1 = true;
4265 }
4266 }
4267 {
4268 PyThreadState* __tstate = wxPyBeginAllowThreads();
4269 result = wxGetUserHome((wxString const &)*arg1);
4270
4271 wxPyEndAllowThreads(__tstate);
4272 if (PyErr_Occurred()) SWIG_fail;
4273 }
4274 {
4275 #if wxUSE_UNICODE
4276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4277 #else
4278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4279 #endif
4280 }
4281 {
4282 if (temp1)
4283 delete arg1;
4284 }
4285 return resultobj;
4286 fail:
4287 {
4288 if (temp1)
4289 delete arg1;
4290 }
4291 return NULL;
4292 }
4293
4294
4295 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4296 PyObject *resultobj;
4297 unsigned long result;
4298 char *kwnames[] = {
4299 NULL
4300 };
4301
4302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 result = (unsigned long)wxGetProcessId();
4306
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 {
4311 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4312 }
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4320 PyObject *resultobj;
4321 char *kwnames[] = {
4322 NULL
4323 };
4324
4325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 wxTrap();
4329
4330 wxPyEndAllowThreads(__tstate);
4331 if (PyErr_Occurred()) SWIG_fail;
4332 }
4333 Py_INCREF(Py_None); resultobj = Py_None;
4334 return resultobj;
4335 fail:
4336 return NULL;
4337 }
4338
4339
4340 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4341 PyObject *resultobj;
4342 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4343 wxString *arg1 = (wxString *) &arg1_defvalue ;
4344 wxString const &arg2_defvalue = wxPyEmptyString ;
4345 wxString *arg2 = (wxString *) &arg2_defvalue ;
4346 wxString const &arg3_defvalue = wxPyEmptyString ;
4347 wxString *arg3 = (wxString *) &arg3_defvalue ;
4348 wxString const &arg4_defvalue = wxPyEmptyString ;
4349 wxString *arg4 = (wxString *) &arg4_defvalue ;
4350 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4351 wxString *arg5 = (wxString *) &arg5_defvalue ;
4352 int arg6 = (int) 0 ;
4353 wxWindow *arg7 = (wxWindow *) NULL ;
4354 int arg8 = (int) -1 ;
4355 int arg9 = (int) -1 ;
4356 wxString result;
4357 bool temp1 = false ;
4358 bool temp2 = false ;
4359 bool temp3 = false ;
4360 bool temp4 = false ;
4361 bool temp5 = false ;
4362 PyObject * obj0 = 0 ;
4363 PyObject * obj1 = 0 ;
4364 PyObject * obj2 = 0 ;
4365 PyObject * obj3 = 0 ;
4366 PyObject * obj4 = 0 ;
4367 PyObject * obj5 = 0 ;
4368 PyObject * obj6 = 0 ;
4369 PyObject * obj7 = 0 ;
4370 PyObject * obj8 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4376 if (obj0) {
4377 {
4378 arg1 = wxString_in_helper(obj0);
4379 if (arg1 == NULL) SWIG_fail;
4380 temp1 = true;
4381 }
4382 }
4383 if (obj1) {
4384 {
4385 arg2 = wxString_in_helper(obj1);
4386 if (arg2 == NULL) SWIG_fail;
4387 temp2 = true;
4388 }
4389 }
4390 if (obj2) {
4391 {
4392 arg3 = wxString_in_helper(obj2);
4393 if (arg3 == NULL) SWIG_fail;
4394 temp3 = true;
4395 }
4396 }
4397 if (obj3) {
4398 {
4399 arg4 = wxString_in_helper(obj3);
4400 if (arg4 == NULL) SWIG_fail;
4401 temp4 = true;
4402 }
4403 }
4404 if (obj4) {
4405 {
4406 arg5 = wxString_in_helper(obj4);
4407 if (arg5 == NULL) SWIG_fail;
4408 temp5 = true;
4409 }
4410 }
4411 if (obj5) {
4412 {
4413 arg6 = (int)(SWIG_As_int(obj5));
4414 if (SWIG_arg_fail(6)) SWIG_fail;
4415 }
4416 }
4417 if (obj6) {
4418 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4419 if (SWIG_arg_fail(7)) SWIG_fail;
4420 }
4421 if (obj7) {
4422 {
4423 arg8 = (int)(SWIG_As_int(obj7));
4424 if (SWIG_arg_fail(8)) SWIG_fail;
4425 }
4426 }
4427 if (obj8) {
4428 {
4429 arg9 = (int)(SWIG_As_int(obj8));
4430 if (SWIG_arg_fail(9)) SWIG_fail;
4431 }
4432 }
4433 {
4434 if (!wxPyCheckForApp()) SWIG_fail;
4435 PyThreadState* __tstate = wxPyBeginAllowThreads();
4436 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4437
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 {
4442 #if wxUSE_UNICODE
4443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4444 #else
4445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4446 #endif
4447 }
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 {
4453 if (temp2)
4454 delete arg2;
4455 }
4456 {
4457 if (temp3)
4458 delete arg3;
4459 }
4460 {
4461 if (temp4)
4462 delete arg4;
4463 }
4464 {
4465 if (temp5)
4466 delete arg5;
4467 }
4468 return resultobj;
4469 fail:
4470 {
4471 if (temp1)
4472 delete arg1;
4473 }
4474 {
4475 if (temp2)
4476 delete arg2;
4477 }
4478 {
4479 if (temp3)
4480 delete arg3;
4481 }
4482 {
4483 if (temp4)
4484 delete arg4;
4485 }
4486 {
4487 if (temp5)
4488 delete arg5;
4489 }
4490 return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj;
4496 wxString *arg1 = 0 ;
4497 wxString *arg2 = 0 ;
4498 wxString const &arg3_defvalue = wxPyEmptyString ;
4499 wxString *arg3 = (wxString *) &arg3_defvalue ;
4500 wxWindow *arg4 = (wxWindow *) NULL ;
4501 wxString result;
4502 bool temp1 = false ;
4503 bool temp2 = false ;
4504 bool temp3 = false ;
4505 PyObject * obj0 = 0 ;
4506 PyObject * obj1 = 0 ;
4507 PyObject * obj2 = 0 ;
4508 PyObject * obj3 = 0 ;
4509 char *kwnames[] = {
4510 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4511 };
4512
4513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4514 {
4515 arg1 = wxString_in_helper(obj0);
4516 if (arg1 == NULL) SWIG_fail;
4517 temp1 = true;
4518 }
4519 {
4520 arg2 = wxString_in_helper(obj1);
4521 if (arg2 == NULL) SWIG_fail;
4522 temp2 = true;
4523 }
4524 if (obj2) {
4525 {
4526 arg3 = wxString_in_helper(obj2);
4527 if (arg3 == NULL) SWIG_fail;
4528 temp3 = true;
4529 }
4530 }
4531 if (obj3) {
4532 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4533 if (SWIG_arg_fail(4)) SWIG_fail;
4534 }
4535 {
4536 if (!wxPyCheckForApp()) SWIG_fail;
4537 PyThreadState* __tstate = wxPyBeginAllowThreads();
4538 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4539
4540 wxPyEndAllowThreads(__tstate);
4541 if (PyErr_Occurred()) SWIG_fail;
4542 }
4543 {
4544 #if wxUSE_UNICODE
4545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4546 #else
4547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4548 #endif
4549 }
4550 {
4551 if (temp1)
4552 delete arg1;
4553 }
4554 {
4555 if (temp2)
4556 delete arg2;
4557 }
4558 {
4559 if (temp3)
4560 delete arg3;
4561 }
4562 return resultobj;
4563 fail:
4564 {
4565 if (temp1)
4566 delete arg1;
4567 }
4568 {
4569 if (temp2)
4570 delete arg2;
4571 }
4572 {
4573 if (temp3)
4574 delete arg3;
4575 }
4576 return NULL;
4577 }
4578
4579
4580 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4581 PyObject *resultobj;
4582 wxString *arg1 = 0 ;
4583 wxString *arg2 = 0 ;
4584 wxString const &arg3_defvalue = wxPyEmptyString ;
4585 wxString *arg3 = (wxString *) &arg3_defvalue ;
4586 wxWindow *arg4 = (wxWindow *) NULL ;
4587 wxString result;
4588 bool temp1 = false ;
4589 bool temp2 = false ;
4590 bool temp3 = false ;
4591 PyObject * obj0 = 0 ;
4592 PyObject * obj1 = 0 ;
4593 PyObject * obj2 = 0 ;
4594 PyObject * obj3 = 0 ;
4595 char *kwnames[] = {
4596 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4597 };
4598
4599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4600 {
4601 arg1 = wxString_in_helper(obj0);
4602 if (arg1 == NULL) SWIG_fail;
4603 temp1 = true;
4604 }
4605 {
4606 arg2 = wxString_in_helper(obj1);
4607 if (arg2 == NULL) SWIG_fail;
4608 temp2 = true;
4609 }
4610 if (obj2) {
4611 {
4612 arg3 = wxString_in_helper(obj2);
4613 if (arg3 == NULL) SWIG_fail;
4614 temp3 = true;
4615 }
4616 }
4617 if (obj3) {
4618 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4619 if (SWIG_arg_fail(4)) SWIG_fail;
4620 }
4621 {
4622 if (!wxPyCheckForApp()) SWIG_fail;
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4625
4626 wxPyEndAllowThreads(__tstate);
4627 if (PyErr_Occurred()) SWIG_fail;
4628 }
4629 {
4630 #if wxUSE_UNICODE
4631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4632 #else
4633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4634 #endif
4635 }
4636 {
4637 if (temp1)
4638 delete arg1;
4639 }
4640 {
4641 if (temp2)
4642 delete arg2;
4643 }
4644 {
4645 if (temp3)
4646 delete arg3;
4647 }
4648 return resultobj;
4649 fail:
4650 {
4651 if (temp1)
4652 delete arg1;
4653 }
4654 {
4655 if (temp2)
4656 delete arg2;
4657 }
4658 {
4659 if (temp3)
4660 delete arg3;
4661 }
4662 return NULL;
4663 }
4664
4665
4666 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj;
4668 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4669 wxString *arg1 = (wxString *) &arg1_defvalue ;
4670 wxString const &arg2_defvalue = wxPyEmptyString ;
4671 wxString *arg2 = (wxString *) &arg2_defvalue ;
4672 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4673 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4674 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4675 wxWindow *arg5 = (wxWindow *) NULL ;
4676 wxString result;
4677 bool temp1 = false ;
4678 bool temp2 = false ;
4679 wxPoint temp4 ;
4680 PyObject * obj0 = 0 ;
4681 PyObject * obj1 = 0 ;
4682 PyObject * obj2 = 0 ;
4683 PyObject * obj3 = 0 ;
4684 PyObject * obj4 = 0 ;
4685 char *kwnames[] = {
4686 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4687 };
4688
4689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4690 if (obj0) {
4691 {
4692 arg1 = wxString_in_helper(obj0);
4693 if (arg1 == NULL) SWIG_fail;
4694 temp1 = true;
4695 }
4696 }
4697 if (obj1) {
4698 {
4699 arg2 = wxString_in_helper(obj1);
4700 if (arg2 == NULL) SWIG_fail;
4701 temp2 = true;
4702 }
4703 }
4704 if (obj2) {
4705 {
4706 arg3 = (long)(SWIG_As_long(obj2));
4707 if (SWIG_arg_fail(3)) SWIG_fail;
4708 }
4709 }
4710 if (obj3) {
4711 {
4712 arg4 = &temp4;
4713 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4714 }
4715 }
4716 if (obj4) {
4717 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(5)) SWIG_fail;
4719 }
4720 {
4721 if (!wxPyCheckForApp()) SWIG_fail;
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4724
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 {
4729 #if wxUSE_UNICODE
4730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4731 #else
4732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4733 #endif
4734 }
4735 {
4736 if (temp1)
4737 delete arg1;
4738 }
4739 {
4740 if (temp2)
4741 delete arg2;
4742 }
4743 return resultobj;
4744 fail:
4745 {
4746 if (temp1)
4747 delete arg1;
4748 }
4749 {
4750 if (temp2)
4751 delete arg2;
4752 }
4753 return NULL;
4754 }
4755
4756
4757 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4758 PyObject *resultobj;
4759 wxString *arg1 = 0 ;
4760 wxString const &arg2_defvalue = wxPyEmptyString ;
4761 wxString *arg2 = (wxString *) &arg2_defvalue ;
4762 wxString const &arg3_defvalue = wxPyEmptyString ;
4763 wxString *arg3 = (wxString *) &arg3_defvalue ;
4764 wxWindow *arg4 = (wxWindow *) NULL ;
4765 int arg5 = (int) -1 ;
4766 int arg6 = (int) -1 ;
4767 bool arg7 = (bool) true ;
4768 wxString result;
4769 bool temp1 = false ;
4770 bool temp2 = false ;
4771 bool temp3 = false ;
4772 PyObject * obj0 = 0 ;
4773 PyObject * obj1 = 0 ;
4774 PyObject * obj2 = 0 ;
4775 PyObject * obj3 = 0 ;
4776 PyObject * obj4 = 0 ;
4777 PyObject * obj5 = 0 ;
4778 PyObject * obj6 = 0 ;
4779 char *kwnames[] = {
4780 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4781 };
4782
4783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4784 {
4785 arg1 = wxString_in_helper(obj0);
4786 if (arg1 == NULL) SWIG_fail;
4787 temp1 = true;
4788 }
4789 if (obj1) {
4790 {
4791 arg2 = wxString_in_helper(obj1);
4792 if (arg2 == NULL) SWIG_fail;
4793 temp2 = true;
4794 }
4795 }
4796 if (obj2) {
4797 {
4798 arg3 = wxString_in_helper(obj2);
4799 if (arg3 == NULL) SWIG_fail;
4800 temp3 = true;
4801 }
4802 }
4803 if (obj3) {
4804 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4805 if (SWIG_arg_fail(4)) SWIG_fail;
4806 }
4807 if (obj4) {
4808 {
4809 arg5 = (int)(SWIG_As_int(obj4));
4810 if (SWIG_arg_fail(5)) SWIG_fail;
4811 }
4812 }
4813 if (obj5) {
4814 {
4815 arg6 = (int)(SWIG_As_int(obj5));
4816 if (SWIG_arg_fail(6)) SWIG_fail;
4817 }
4818 }
4819 if (obj6) {
4820 {
4821 arg7 = (bool)(SWIG_As_bool(obj6));
4822 if (SWIG_arg_fail(7)) SWIG_fail;
4823 }
4824 }
4825 {
4826 if (!wxPyCheckForApp()) SWIG_fail;
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4829
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 {
4834 #if wxUSE_UNICODE
4835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4836 #else
4837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4838 #endif
4839 }
4840 {
4841 if (temp1)
4842 delete arg1;
4843 }
4844 {
4845 if (temp2)
4846 delete arg2;
4847 }
4848 {
4849 if (temp3)
4850 delete arg3;
4851 }
4852 return resultobj;
4853 fail:
4854 {
4855 if (temp1)
4856 delete arg1;
4857 }
4858 {
4859 if (temp2)
4860 delete arg2;
4861 }
4862 {
4863 if (temp3)
4864 delete arg3;
4865 }
4866 return NULL;
4867 }
4868
4869
4870 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj;
4872 wxString *arg1 = 0 ;
4873 wxString const &arg2_defvalue = wxPyEmptyString ;
4874 wxString *arg2 = (wxString *) &arg2_defvalue ;
4875 wxString const &arg3_defvalue = wxPyEmptyString ;
4876 wxString *arg3 = (wxString *) &arg3_defvalue ;
4877 wxWindow *arg4 = (wxWindow *) NULL ;
4878 wxString result;
4879 bool temp1 = false ;
4880 bool temp2 = false ;
4881 bool temp3 = false ;
4882 PyObject * obj0 = 0 ;
4883 PyObject * obj1 = 0 ;
4884 PyObject * obj2 = 0 ;
4885 PyObject * obj3 = 0 ;
4886 char *kwnames[] = {
4887 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4888 };
4889
4890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4891 {
4892 arg1 = wxString_in_helper(obj0);
4893 if (arg1 == NULL) SWIG_fail;
4894 temp1 = true;
4895 }
4896 if (obj1) {
4897 {
4898 arg2 = wxString_in_helper(obj1);
4899 if (arg2 == NULL) SWIG_fail;
4900 temp2 = true;
4901 }
4902 }
4903 if (obj2) {
4904 {
4905 arg3 = wxString_in_helper(obj2);
4906 if (arg3 == NULL) SWIG_fail;
4907 temp3 = true;
4908 }
4909 }
4910 if (obj3) {
4911 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4912 if (SWIG_arg_fail(4)) SWIG_fail;
4913 }
4914 {
4915 if (!wxPyCheckForApp()) SWIG_fail;
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 {
4923 #if wxUSE_UNICODE
4924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4925 #else
4926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4927 #endif
4928 }
4929 {
4930 if (temp1)
4931 delete arg1;
4932 }
4933 {
4934 if (temp2)
4935 delete arg2;
4936 }
4937 {
4938 if (temp3)
4939 delete arg3;
4940 }
4941 return resultobj;
4942 fail:
4943 {
4944 if (temp1)
4945 delete arg1;
4946 }
4947 {
4948 if (temp2)
4949 delete arg2;
4950 }
4951 {
4952 if (temp3)
4953 delete arg3;
4954 }
4955 return NULL;
4956 }
4957
4958
4959 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4960 PyObject *resultobj;
4961 wxString *arg1 = 0 ;
4962 wxString *arg2 = 0 ;
4963 int arg3 ;
4964 wxString *arg4 = (wxString *) 0 ;
4965 wxWindow *arg5 = (wxWindow *) NULL ;
4966 int arg6 = (int) -1 ;
4967 int arg7 = (int) -1 ;
4968 bool arg8 = (bool) true ;
4969 int arg9 = (int) 150 ;
4970 int arg10 = (int) 200 ;
4971 wxString result;
4972 bool temp1 = false ;
4973 bool temp2 = false ;
4974 PyObject * obj0 = 0 ;
4975 PyObject * obj1 = 0 ;
4976 PyObject * obj2 = 0 ;
4977 PyObject * obj3 = 0 ;
4978 PyObject * obj4 = 0 ;
4979 PyObject * obj5 = 0 ;
4980 PyObject * obj6 = 0 ;
4981 PyObject * obj7 = 0 ;
4982 PyObject * obj8 = 0 ;
4983 char *kwnames[] = {
4984 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4985 };
4986
4987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4988 {
4989 arg1 = wxString_in_helper(obj0);
4990 if (arg1 == NULL) SWIG_fail;
4991 temp1 = true;
4992 }
4993 {
4994 arg2 = wxString_in_helper(obj1);
4995 if (arg2 == NULL) SWIG_fail;
4996 temp2 = true;
4997 }
4998 {
4999 arg3 = PyList_Size(obj2);
5000 arg4 = wxString_LIST_helper(obj2);
5001 if (arg4 == NULL) SWIG_fail;
5002 }
5003 if (obj3) {
5004 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5005 if (SWIG_arg_fail(5)) SWIG_fail;
5006 }
5007 if (obj4) {
5008 {
5009 arg6 = (int)(SWIG_As_int(obj4));
5010 if (SWIG_arg_fail(6)) SWIG_fail;
5011 }
5012 }
5013 if (obj5) {
5014 {
5015 arg7 = (int)(SWIG_As_int(obj5));
5016 if (SWIG_arg_fail(7)) SWIG_fail;
5017 }
5018 }
5019 if (obj6) {
5020 {
5021 arg8 = (bool)(SWIG_As_bool(obj6));
5022 if (SWIG_arg_fail(8)) SWIG_fail;
5023 }
5024 }
5025 if (obj7) {
5026 {
5027 arg9 = (int)(SWIG_As_int(obj7));
5028 if (SWIG_arg_fail(9)) SWIG_fail;
5029 }
5030 }
5031 if (obj8) {
5032 {
5033 arg10 = (int)(SWIG_As_int(obj8));
5034 if (SWIG_arg_fail(10)) SWIG_fail;
5035 }
5036 }
5037 {
5038 if (!wxPyCheckForApp()) SWIG_fail;
5039 PyThreadState* __tstate = wxPyBeginAllowThreads();
5040 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5041
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 #if wxUSE_UNICODE
5047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5048 #else
5049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5050 #endif
5051 }
5052 {
5053 if (temp1)
5054 delete arg1;
5055 }
5056 {
5057 if (temp2)
5058 delete arg2;
5059 }
5060 {
5061 if (arg4) delete [] arg4;
5062 }
5063 return resultobj;
5064 fail:
5065 {
5066 if (temp1)
5067 delete arg1;
5068 }
5069 {
5070 if (temp2)
5071 delete arg2;
5072 }
5073 {
5074 if (arg4) delete [] arg4;
5075 }
5076 return NULL;
5077 }
5078
5079
5080 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5081 PyObject *resultobj;
5082 wxString *arg1 = 0 ;
5083 wxString *arg2 = 0 ;
5084 int arg3 ;
5085 wxString *arg4 = (wxString *) 0 ;
5086 wxWindow *arg5 = (wxWindow *) NULL ;
5087 int arg6 = (int) -1 ;
5088 int arg7 = (int) -1 ;
5089 bool arg8 = (bool) true ;
5090 int arg9 = (int) 150 ;
5091 int arg10 = (int) 200 ;
5092 int result;
5093 bool temp1 = false ;
5094 bool temp2 = false ;
5095 PyObject * obj0 = 0 ;
5096 PyObject * obj1 = 0 ;
5097 PyObject * obj2 = 0 ;
5098 PyObject * obj3 = 0 ;
5099 PyObject * obj4 = 0 ;
5100 PyObject * obj5 = 0 ;
5101 PyObject * obj6 = 0 ;
5102 PyObject * obj7 = 0 ;
5103 PyObject * obj8 = 0 ;
5104 char *kwnames[] = {
5105 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5106 };
5107
5108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5109 {
5110 arg1 = wxString_in_helper(obj0);
5111 if (arg1 == NULL) SWIG_fail;
5112 temp1 = true;
5113 }
5114 {
5115 arg2 = wxString_in_helper(obj1);
5116 if (arg2 == NULL) SWIG_fail;
5117 temp2 = true;
5118 }
5119 {
5120 arg3 = PyList_Size(obj2);
5121 arg4 = wxString_LIST_helper(obj2);
5122 if (arg4 == NULL) SWIG_fail;
5123 }
5124 if (obj3) {
5125 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5126 if (SWIG_arg_fail(5)) SWIG_fail;
5127 }
5128 if (obj4) {
5129 {
5130 arg6 = (int)(SWIG_As_int(obj4));
5131 if (SWIG_arg_fail(6)) SWIG_fail;
5132 }
5133 }
5134 if (obj5) {
5135 {
5136 arg7 = (int)(SWIG_As_int(obj5));
5137 if (SWIG_arg_fail(7)) SWIG_fail;
5138 }
5139 }
5140 if (obj6) {
5141 {
5142 arg8 = (bool)(SWIG_As_bool(obj6));
5143 if (SWIG_arg_fail(8)) SWIG_fail;
5144 }
5145 }
5146 if (obj7) {
5147 {
5148 arg9 = (int)(SWIG_As_int(obj7));
5149 if (SWIG_arg_fail(9)) SWIG_fail;
5150 }
5151 }
5152 if (obj8) {
5153 {
5154 arg10 = (int)(SWIG_As_int(obj8));
5155 if (SWIG_arg_fail(10)) SWIG_fail;
5156 }
5157 }
5158 {
5159 if (!wxPyCheckForApp()) SWIG_fail;
5160 PyThreadState* __tstate = wxPyBeginAllowThreads();
5161 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5162
5163 wxPyEndAllowThreads(__tstate);
5164 if (PyErr_Occurred()) SWIG_fail;
5165 }
5166 {
5167 resultobj = SWIG_From_int((int)(result));
5168 }
5169 {
5170 if (temp1)
5171 delete arg1;
5172 }
5173 {
5174 if (temp2)
5175 delete arg2;
5176 }
5177 {
5178 if (arg4) delete [] arg4;
5179 }
5180 return resultobj;
5181 fail:
5182 {
5183 if (temp1)
5184 delete arg1;
5185 }
5186 {
5187 if (temp2)
5188 delete arg2;
5189 }
5190 {
5191 if (arg4) delete [] arg4;
5192 }
5193 return NULL;
5194 }
5195
5196
5197 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj;
5199 wxString *arg1 = 0 ;
5200 wxString const &arg2_defvalue = wxPyEmptyString ;
5201 wxString *arg2 = (wxString *) &arg2_defvalue ;
5202 int arg3 = (int) wxOK|wxCENTRE ;
5203 wxWindow *arg4 = (wxWindow *) NULL ;
5204 int arg5 = (int) -1 ;
5205 int arg6 = (int) -1 ;
5206 int result;
5207 bool temp1 = false ;
5208 bool temp2 = false ;
5209 PyObject * obj0 = 0 ;
5210 PyObject * obj1 = 0 ;
5211 PyObject * obj2 = 0 ;
5212 PyObject * obj3 = 0 ;
5213 PyObject * obj4 = 0 ;
5214 PyObject * obj5 = 0 ;
5215 char *kwnames[] = {
5216 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5217 };
5218
5219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5220 {
5221 arg1 = wxString_in_helper(obj0);
5222 if (arg1 == NULL) SWIG_fail;
5223 temp1 = true;
5224 }
5225 if (obj1) {
5226 {
5227 arg2 = wxString_in_helper(obj1);
5228 if (arg2 == NULL) SWIG_fail;
5229 temp2 = true;
5230 }
5231 }
5232 if (obj2) {
5233 {
5234 arg3 = (int)(SWIG_As_int(obj2));
5235 if (SWIG_arg_fail(3)) SWIG_fail;
5236 }
5237 }
5238 if (obj3) {
5239 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5240 if (SWIG_arg_fail(4)) SWIG_fail;
5241 }
5242 if (obj4) {
5243 {
5244 arg5 = (int)(SWIG_As_int(obj4));
5245 if (SWIG_arg_fail(5)) SWIG_fail;
5246 }
5247 }
5248 if (obj5) {
5249 {
5250 arg6 = (int)(SWIG_As_int(obj5));
5251 if (SWIG_arg_fail(6)) SWIG_fail;
5252 }
5253 }
5254 {
5255 if (!wxPyCheckForApp()) SWIG_fail;
5256 PyThreadState* __tstate = wxPyBeginAllowThreads();
5257 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5258
5259 wxPyEndAllowThreads(__tstate);
5260 if (PyErr_Occurred()) SWIG_fail;
5261 }
5262 {
5263 resultobj = SWIG_From_int((int)(result));
5264 }
5265 {
5266 if (temp1)
5267 delete arg1;
5268 }
5269 {
5270 if (temp2)
5271 delete arg2;
5272 }
5273 return resultobj;
5274 fail:
5275 {
5276 if (temp1)
5277 delete arg1;
5278 }
5279 {
5280 if (temp2)
5281 delete arg2;
5282 }
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj;
5289 wxString *arg1 = 0 ;
5290 wxString *arg2 = 0 ;
5291 wxString *arg3 = 0 ;
5292 long arg4 ;
5293 long arg5 = (long) 0 ;
5294 long arg6 = (long) 100 ;
5295 wxWindow *arg7 = (wxWindow *) NULL ;
5296 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5297 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5298 long result;
5299 bool temp1 = false ;
5300 bool temp2 = false ;
5301 bool temp3 = false ;
5302 wxPoint temp8 ;
5303 PyObject * obj0 = 0 ;
5304 PyObject * obj1 = 0 ;
5305 PyObject * obj2 = 0 ;
5306 PyObject * obj3 = 0 ;
5307 PyObject * obj4 = 0 ;
5308 PyObject * obj5 = 0 ;
5309 PyObject * obj6 = 0 ;
5310 PyObject * obj7 = 0 ;
5311 char *kwnames[] = {
5312 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5313 };
5314
5315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5316 {
5317 arg1 = wxString_in_helper(obj0);
5318 if (arg1 == NULL) SWIG_fail;
5319 temp1 = true;
5320 }
5321 {
5322 arg2 = wxString_in_helper(obj1);
5323 if (arg2 == NULL) SWIG_fail;
5324 temp2 = true;
5325 }
5326 {
5327 arg3 = wxString_in_helper(obj2);
5328 if (arg3 == NULL) SWIG_fail;
5329 temp3 = true;
5330 }
5331 {
5332 arg4 = (long)(SWIG_As_long(obj3));
5333 if (SWIG_arg_fail(4)) SWIG_fail;
5334 }
5335 if (obj4) {
5336 {
5337 arg5 = (long)(SWIG_As_long(obj4));
5338 if (SWIG_arg_fail(5)) SWIG_fail;
5339 }
5340 }
5341 if (obj5) {
5342 {
5343 arg6 = (long)(SWIG_As_long(obj5));
5344 if (SWIG_arg_fail(6)) SWIG_fail;
5345 }
5346 }
5347 if (obj6) {
5348 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5349 if (SWIG_arg_fail(7)) SWIG_fail;
5350 }
5351 if (obj7) {
5352 {
5353 arg8 = &temp8;
5354 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5355 }
5356 }
5357 {
5358 if (!wxPyCheckForApp()) SWIG_fail;
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5361
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 {
5366 resultobj = SWIG_From_long((long)(result));
5367 }
5368 {
5369 if (temp1)
5370 delete arg1;
5371 }
5372 {
5373 if (temp2)
5374 delete arg2;
5375 }
5376 {
5377 if (temp3)
5378 delete arg3;
5379 }
5380 return resultobj;
5381 fail:
5382 {
5383 if (temp1)
5384 delete arg1;
5385 }
5386 {
5387 if (temp2)
5388 delete arg2;
5389 }
5390 {
5391 if (temp3)
5392 delete arg3;
5393 }
5394 return NULL;
5395 }
5396
5397
5398 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5399 PyObject *resultobj;
5400 bool result;
5401 char *kwnames[] = {
5402 NULL
5403 };
5404
5405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5406 {
5407 if (!wxPyCheckForApp()) SWIG_fail;
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 result = (bool)wxColourDisplay();
5410
5411 wxPyEndAllowThreads(__tstate);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 {
5415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5416 }
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5424 PyObject *resultobj;
5425 int result;
5426 char *kwnames[] = {
5427 NULL
5428 };
5429
5430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5431 {
5432 if (!wxPyCheckForApp()) SWIG_fail;
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (int)wxDisplayDepth();
5435
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 resultobj = SWIG_From_int((int)(result));
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5449 PyObject *resultobj;
5450 int result;
5451 char *kwnames[] = {
5452 NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5456 {
5457 if (!wxPyCheckForApp()) SWIG_fail;
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = (int)wxGetDisplayDepth();
5460
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 {
5465 resultobj = SWIG_From_int((int)(result));
5466 }
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5474 PyObject *resultobj;
5475 int *arg1 = (int *) 0 ;
5476 int *arg2 = (int *) 0 ;
5477 int temp1 ;
5478 int res1 = 0 ;
5479 int temp2 ;
5480 int res2 = 0 ;
5481 char *kwnames[] = {
5482 NULL
5483 };
5484
5485 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5486 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5488 {
5489 if (!wxPyCheckForApp()) SWIG_fail;
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 wxDisplaySize(arg1,arg2);
5492
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 Py_INCREF(Py_None); resultobj = Py_None;
5497 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5498 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5499 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5500 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj;
5509 wxSize result;
5510 char *kwnames[] = {
5511 NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5515 {
5516 if (!wxPyCheckForApp()) SWIG_fail;
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 result = wxGetDisplaySize();
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 wxSize * resultptr;
5525 resultptr = new wxSize((wxSize &)(result));
5526 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5527 }
5528 return resultobj;
5529 fail:
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 int *arg1 = (int *) 0 ;
5537 int *arg2 = (int *) 0 ;
5538 int temp1 ;
5539 int res1 = 0 ;
5540 int temp2 ;
5541 int res2 = 0 ;
5542 char *kwnames[] = {
5543 NULL
5544 };
5545
5546 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5547 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5549 {
5550 if (!wxPyCheckForApp()) SWIG_fail;
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 wxDisplaySizeMM(arg1,arg2);
5553
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 Py_INCREF(Py_None); resultobj = Py_None;
5558 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5559 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5560 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5561 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj;
5570 wxSize result;
5571 char *kwnames[] = {
5572 NULL
5573 };
5574
5575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5576 {
5577 if (!wxPyCheckForApp()) SWIG_fail;
5578 PyThreadState* __tstate = wxPyBeginAllowThreads();
5579 result = wxGetDisplaySizeMM();
5580
5581 wxPyEndAllowThreads(__tstate);
5582 if (PyErr_Occurred()) SWIG_fail;
5583 }
5584 {
5585 wxSize * resultptr;
5586 resultptr = new wxSize((wxSize &)(result));
5587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5588 }
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj;
5597 int *arg1 = (int *) 0 ;
5598 int *arg2 = (int *) 0 ;
5599 int *arg3 = (int *) 0 ;
5600 int *arg4 = (int *) 0 ;
5601 int temp1 ;
5602 int res1 = 0 ;
5603 int temp2 ;
5604 int res2 = 0 ;
5605 int temp3 ;
5606 int res3 = 0 ;
5607 int temp4 ;
5608 int res4 = 0 ;
5609 char *kwnames[] = {
5610 NULL
5611 };
5612
5613 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5614 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5615 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5616 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5618 {
5619 if (!wxPyCheckForApp()) SWIG_fail;
5620 PyThreadState* __tstate = wxPyBeginAllowThreads();
5621 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5622
5623 wxPyEndAllowThreads(__tstate);
5624 if (PyErr_Occurred()) SWIG_fail;
5625 }
5626 Py_INCREF(Py_None); resultobj = Py_None;
5627 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5628 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5629 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5630 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5631 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5632 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5633 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5634 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5642 PyObject *resultobj;
5643 wxRect result;
5644 char *kwnames[] = {
5645 NULL
5646 };
5647
5648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5649 {
5650 if (!wxPyCheckForApp()) SWIG_fail;
5651 PyThreadState* __tstate = wxPyBeginAllowThreads();
5652 result = wxGetClientDisplayRect();
5653
5654 wxPyEndAllowThreads(__tstate);
5655 if (PyErr_Occurred()) SWIG_fail;
5656 }
5657 {
5658 wxRect * resultptr;
5659 resultptr = new wxRect((wxRect &)(result));
5660 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5661 }
5662 return resultobj;
5663 fail:
5664 return NULL;
5665 }
5666
5667
5668 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5669 PyObject *resultobj;
5670 wxCursor *arg1 = 0 ;
5671 PyObject * obj0 = 0 ;
5672 char *kwnames[] = {
5673 (char *) "cursor", NULL
5674 };
5675
5676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5677 {
5678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5679 if (SWIG_arg_fail(1)) SWIG_fail;
5680 if (arg1 == NULL) {
5681 SWIG_null_ref("wxCursor");
5682 }
5683 if (SWIG_arg_fail(1)) SWIG_fail;
5684 }
5685 {
5686 if (!wxPyCheckForApp()) SWIG_fail;
5687 PyThreadState* __tstate = wxPyBeginAllowThreads();
5688 wxSetCursor(*arg1);
5689
5690 wxPyEndAllowThreads(__tstate);
5691 if (PyErr_Occurred()) SWIG_fail;
5692 }
5693 Py_INCREF(Py_None); resultobj = Py_None;
5694 return resultobj;
5695 fail:
5696 return NULL;
5697 }
5698
5699
5700 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5701 PyObject *resultobj;
5702 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5703 PyObject * obj0 = 0 ;
5704 char *kwnames[] = {
5705 (char *) "cursor", NULL
5706 };
5707
5708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5709 if (obj0) {
5710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5711 if (SWIG_arg_fail(1)) SWIG_fail;
5712 }
5713 {
5714 if (!wxPyCheckForApp()) SWIG_fail;
5715 PyThreadState* __tstate = wxPyBeginAllowThreads();
5716 wxBeginBusyCursor(arg1);
5717
5718 wxPyEndAllowThreads(__tstate);
5719 if (PyErr_Occurred()) SWIG_fail;
5720 }
5721 Py_INCREF(Py_None); resultobj = Py_None;
5722 return resultobj;
5723 fail:
5724 return NULL;
5725 }
5726
5727
5728 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5729 PyObject *resultobj;
5730 wxWindow *result;
5731 char *kwnames[] = {
5732 NULL
5733 };
5734
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5736 {
5737 if (!wxPyCheckForApp()) SWIG_fail;
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (wxWindow *)wxGetActiveWindow();
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 {
5745 resultobj = wxPyMake_wxObject(result, 0);
5746 }
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj;
5755 wxPoint *arg1 = 0 ;
5756 wxWindow *result;
5757 wxPoint temp1 ;
5758 PyObject * obj0 = 0 ;
5759 char *kwnames[] = {
5760 (char *) "pt", NULL
5761 };
5762
5763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5764 {
5765 arg1 = &temp1;
5766 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5767 }
5768 {
5769 if (!wxPyCheckForApp()) SWIG_fail;
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5772
5773 wxPyEndAllowThreads(__tstate);
5774 if (PyErr_Occurred()) SWIG_fail;
5775 }
5776 {
5777 resultobj = wxPyMake_wxObject(result, 0);
5778 }
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj;
5787 wxPoint *arg1 = 0 ;
5788 wxWindow *result;
5789 wxPoint temp1 ;
5790 PyObject * obj0 = 0 ;
5791 char *kwnames[] = {
5792 (char *) "pt", NULL
5793 };
5794
5795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5796 {
5797 arg1 = &temp1;
5798 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5799 }
5800 {
5801 if (!wxPyCheckForApp()) SWIG_fail;
5802 PyThreadState* __tstate = wxPyBeginAllowThreads();
5803 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5804
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 {
5809 resultobj = wxPyMake_wxObject(result, 0);
5810 }
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj;
5819 wxWindow *arg1 = (wxWindow *) 0 ;
5820 wxWindow *result;
5821 PyObject * obj0 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "win", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 {
5830 if (!wxPyCheckForApp()) SWIG_fail;
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 result = (wxWindow *)wxGetTopLevelParent(arg1);
5833
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 resultobj = wxPyMake_wxObject(result, 0);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxKeyCode arg1 ;
5849 bool result;
5850 PyObject * obj0 = 0 ;
5851 char *kwnames[] = {
5852 (char *) "key", NULL
5853 };
5854
5855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5856 {
5857 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5858 if (SWIG_arg_fail(1)) SWIG_fail;
5859 }
5860 {
5861 if (!wxPyCheckForApp()) SWIG_fail;
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 {
5869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5870 }
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj;
5879 char *kwnames[] = {
5880 NULL
5881 };
5882
5883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5884 {
5885 if (!wxPyCheckForApp()) SWIG_fail;
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 wxWakeUpMainThread();
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 Py_INCREF(Py_None); resultobj = Py_None;
5893 return resultobj;
5894 fail:
5895 return NULL;
5896 }
5897
5898
5899 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5900 PyObject *resultobj;
5901 char *kwnames[] = {
5902 NULL
5903 };
5904
5905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5906 {
5907 if (!wxPyCheckForApp()) SWIG_fail;
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 wxMutexGuiEnter();
5910
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 Py_INCREF(Py_None); resultobj = Py_None;
5915 return resultobj;
5916 fail:
5917 return NULL;
5918 }
5919
5920
5921 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5922 PyObject *resultobj;
5923 char *kwnames[] = {
5924 NULL
5925 };
5926
5927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5928 {
5929 if (!wxPyCheckForApp()) SWIG_fail;
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 wxMutexGuiLeave();
5932
5933 wxPyEndAllowThreads(__tstate);
5934 if (PyErr_Occurred()) SWIG_fail;
5935 }
5936 Py_INCREF(Py_None); resultobj = Py_None;
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj;
5945 wxMutexGuiLocker *result;
5946 char *kwnames[] = {
5947 NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5951 {
5952 if (!wxPyCheckForApp()) SWIG_fail;
5953 PyThreadState* __tstate = wxPyBeginAllowThreads();
5954 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5955
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj;
5968 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5969 PyObject * obj0 = 0 ;
5970 char *kwnames[] = {
5971 (char *) "self", NULL
5972 };
5973
5974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5976 if (SWIG_arg_fail(1)) SWIG_fail;
5977 {
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 delete arg1;
5980
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 Py_INCREF(Py_None); resultobj = Py_None;
5985 return resultobj;
5986 fail:
5987 return NULL;
5988 }
5989
5990
5991 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5992 PyObject *obj;
5993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5994 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
5995 Py_INCREF(obj);
5996 return Py_BuildValue((char *)"");
5997 }
5998 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj;
6000 bool result;
6001 char *kwnames[] = {
6002 NULL
6003 };
6004
6005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6006 {
6007 PyThreadState* __tstate = wxPyBeginAllowThreads();
6008 result = (bool)wxThread_IsMain();
6009
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 {
6014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6015 }
6016 return resultobj;
6017 fail:
6018 return NULL;
6019 }
6020
6021
6022 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6023 PyObject *resultobj;
6024 wxString *arg1 = 0 ;
6025 wxToolTip *result;
6026 bool temp1 = false ;
6027 PyObject * obj0 = 0 ;
6028 char *kwnames[] = {
6029 (char *) "tip", NULL
6030 };
6031
6032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6033 {
6034 arg1 = wxString_in_helper(obj0);
6035 if (arg1 == NULL) SWIG_fail;
6036 temp1 = true;
6037 }
6038 {
6039 if (!wxPyCheckForApp()) SWIG_fail;
6040 PyThreadState* __tstate = wxPyBeginAllowThreads();
6041 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6042
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 {
6047 resultobj = wxPyMake_wxObject(result, 1);
6048 }
6049 {
6050 if (temp1)
6051 delete arg1;
6052 }
6053 return resultobj;
6054 fail:
6055 {
6056 if (temp1)
6057 delete arg1;
6058 }
6059 return NULL;
6060 }
6061
6062
6063 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6064 PyObject *resultobj;
6065 wxToolTip *arg1 = (wxToolTip *) 0 ;
6066 wxString *arg2 = 0 ;
6067 bool temp2 = false ;
6068 PyObject * obj0 = 0 ;
6069 PyObject * obj1 = 0 ;
6070 char *kwnames[] = {
6071 (char *) "self",(char *) "tip", NULL
6072 };
6073
6074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6076 if (SWIG_arg_fail(1)) SWIG_fail;
6077 {
6078 arg2 = wxString_in_helper(obj1);
6079 if (arg2 == NULL) SWIG_fail;
6080 temp2 = true;
6081 }
6082 {
6083 PyThreadState* __tstate = wxPyBeginAllowThreads();
6084 (arg1)->SetTip((wxString const &)*arg2);
6085
6086 wxPyEndAllowThreads(__tstate);
6087 if (PyErr_Occurred()) SWIG_fail;
6088 }
6089 Py_INCREF(Py_None); resultobj = Py_None;
6090 {
6091 if (temp2)
6092 delete arg2;
6093 }
6094 return resultobj;
6095 fail:
6096 {
6097 if (temp2)
6098 delete arg2;
6099 }
6100 return NULL;
6101 }
6102
6103
6104 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj;
6106 wxToolTip *arg1 = (wxToolTip *) 0 ;
6107 wxString result;
6108 PyObject * obj0 = 0 ;
6109 char *kwnames[] = {
6110 (char *) "self", NULL
6111 };
6112
6113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6115 if (SWIG_arg_fail(1)) SWIG_fail;
6116 {
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 result = (arg1)->GetTip();
6119
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 {
6124 #if wxUSE_UNICODE
6125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6126 #else
6127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6128 #endif
6129 }
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj;
6138 wxToolTip *arg1 = (wxToolTip *) 0 ;
6139 wxWindow *result;
6140 PyObject * obj0 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 {
6149 PyThreadState* __tstate = wxPyBeginAllowThreads();
6150 result = (wxWindow *)(arg1)->GetWindow();
6151
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 {
6156 resultobj = wxPyMake_wxObject(result, 0);
6157 }
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6165 PyObject *resultobj;
6166 bool arg1 ;
6167 PyObject * obj0 = 0 ;
6168 char *kwnames[] = {
6169 (char *) "flag", NULL
6170 };
6171
6172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6173 {
6174 arg1 = (bool)(SWIG_As_bool(obj0));
6175 if (SWIG_arg_fail(1)) SWIG_fail;
6176 }
6177 {
6178 PyThreadState* __tstate = wxPyBeginAllowThreads();
6179 wxToolTip::Enable(arg1);
6180
6181 wxPyEndAllowThreads(__tstate);
6182 if (PyErr_Occurred()) SWIG_fail;
6183 }
6184 Py_INCREF(Py_None); resultobj = Py_None;
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj;
6193 long arg1 ;
6194 PyObject * obj0 = 0 ;
6195 char *kwnames[] = {
6196 (char *) "milliseconds", NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6200 {
6201 arg1 = (long)(SWIG_As_long(obj0));
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 }
6204 {
6205 PyThreadState* __tstate = wxPyBeginAllowThreads();
6206 wxToolTip::SetDelay(arg1);
6207
6208 wxPyEndAllowThreads(__tstate);
6209 if (PyErr_Occurred()) SWIG_fail;
6210 }
6211 Py_INCREF(Py_None); resultobj = Py_None;
6212 return resultobj;
6213 fail:
6214 return NULL;
6215 }
6216
6217
6218 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6219 PyObject *obj;
6220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6221 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6222 Py_INCREF(obj);
6223 return Py_BuildValue((char *)"");
6224 }
6225 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6226 PyObject *resultobj;
6227 wxWindow *arg1 = (wxWindow *) 0 ;
6228 wxSize *arg2 = 0 ;
6229 wxCaret *result;
6230 wxSize temp2 ;
6231 PyObject * obj0 = 0 ;
6232 PyObject * obj1 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "window",(char *) "size", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 {
6241 arg2 = &temp2;
6242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6243 }
6244 {
6245 if (!wxPyCheckForApp()) SWIG_fail;
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6260 PyObject *resultobj;
6261 wxCaret *arg1 = (wxCaret *) 0 ;
6262 PyObject * obj0 = 0 ;
6263 char *kwnames[] = {
6264 (char *) "self", NULL
6265 };
6266
6267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6269 if (SWIG_arg_fail(1)) SWIG_fail;
6270 {
6271 PyThreadState* __tstate = wxPyBeginAllowThreads();
6272 wxCaret_Destroy(arg1);
6273
6274 wxPyEndAllowThreads(__tstate);
6275 if (PyErr_Occurred()) SWIG_fail;
6276 }
6277 Py_INCREF(Py_None); resultobj = Py_None;
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj;
6286 wxCaret *arg1 = (wxCaret *) 0 ;
6287 bool result;
6288 PyObject * obj0 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "self", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6295 if (SWIG_arg_fail(1)) SWIG_fail;
6296 {
6297 PyThreadState* __tstate = wxPyBeginAllowThreads();
6298 result = (bool)(arg1)->IsOk();
6299
6300 wxPyEndAllowThreads(__tstate);
6301 if (PyErr_Occurred()) SWIG_fail;
6302 }
6303 {
6304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6305 }
6306 return resultobj;
6307 fail:
6308 return NULL;
6309 }
6310
6311
6312 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6313 PyObject *resultobj;
6314 wxCaret *arg1 = (wxCaret *) 0 ;
6315 bool result;
6316 PyObject * obj0 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "self", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 {
6325 PyThreadState* __tstate = wxPyBeginAllowThreads();
6326 result = (bool)(arg1)->IsVisible();
6327
6328 wxPyEndAllowThreads(__tstate);
6329 if (PyErr_Occurred()) SWIG_fail;
6330 }
6331 {
6332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6333 }
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6341 PyObject *resultobj;
6342 wxCaret *arg1 = (wxCaret *) 0 ;
6343 wxPoint result;
6344 PyObject * obj0 = 0 ;
6345 char *kwnames[] = {
6346 (char *) "self", NULL
6347 };
6348
6349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6351 if (SWIG_arg_fail(1)) SWIG_fail;
6352 {
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 result = (arg1)->GetPosition();
6355
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 {
6360 wxPoint * resultptr;
6361 resultptr = new wxPoint((wxPoint &)(result));
6362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6363 }
6364 return resultobj;
6365 fail:
6366 return NULL;
6367 }
6368
6369
6370 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6371 PyObject *resultobj;
6372 wxCaret *arg1 = (wxCaret *) 0 ;
6373 int *arg2 = (int *) 0 ;
6374 int *arg3 = (int *) 0 ;
6375 int temp2 ;
6376 int res2 = 0 ;
6377 int temp3 ;
6378 int res3 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 char *kwnames[] = {
6381 (char *) "self", NULL
6382 };
6383
6384 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6385 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6388 if (SWIG_arg_fail(1)) SWIG_fail;
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 (arg1)->GetPosition(arg2,arg3);
6392
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 Py_INCREF(Py_None); resultobj = Py_None;
6397 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6398 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6399 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6400 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6401 return resultobj;
6402 fail:
6403 return NULL;
6404 }
6405
6406
6407 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6408 PyObject *resultobj;
6409 wxCaret *arg1 = (wxCaret *) 0 ;
6410 wxSize result;
6411 PyObject * obj0 = 0 ;
6412 char *kwnames[] = {
6413 (char *) "self", NULL
6414 };
6415
6416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6418 if (SWIG_arg_fail(1)) SWIG_fail;
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 result = (arg1)->GetSize();
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 {
6427 wxSize * resultptr;
6428 resultptr = new wxSize((wxSize &)(result));
6429 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6430 }
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj;
6439 wxCaret *arg1 = (wxCaret *) 0 ;
6440 int *arg2 = (int *) 0 ;
6441 int *arg3 = (int *) 0 ;
6442 int temp2 ;
6443 int res2 = 0 ;
6444 int temp3 ;
6445 int res3 = 0 ;
6446 PyObject * obj0 = 0 ;
6447 char *kwnames[] = {
6448 (char *) "self", NULL
6449 };
6450
6451 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6452 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6455 if (SWIG_arg_fail(1)) SWIG_fail;
6456 {
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 (arg1)->GetSize(arg2,arg3);
6459
6460 wxPyEndAllowThreads(__tstate);
6461 if (PyErr_Occurred()) SWIG_fail;
6462 }
6463 Py_INCREF(Py_None); resultobj = Py_None;
6464 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6465 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6466 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6467 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj;
6476 wxCaret *arg1 = (wxCaret *) 0 ;
6477 wxWindow *result;
6478 PyObject * obj0 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "self", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6485 if (SWIG_arg_fail(1)) SWIG_fail;
6486 {
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = (wxWindow *)(arg1)->GetWindow();
6489
6490 wxPyEndAllowThreads(__tstate);
6491 if (PyErr_Occurred()) SWIG_fail;
6492 }
6493 {
6494 resultobj = wxPyMake_wxObject(result, 0);
6495 }
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxCaret *arg1 = (wxCaret *) 0 ;
6505 int arg2 ;
6506 int arg3 ;
6507 PyObject * obj0 = 0 ;
6508 PyObject * obj1 = 0 ;
6509 PyObject * obj2 = 0 ;
6510 char *kwnames[] = {
6511 (char *) "self",(char *) "x",(char *) "y", NULL
6512 };
6513
6514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6516 if (SWIG_arg_fail(1)) SWIG_fail;
6517 {
6518 arg2 = (int)(SWIG_As_int(obj1));
6519 if (SWIG_arg_fail(2)) SWIG_fail;
6520 }
6521 {
6522 arg3 = (int)(SWIG_As_int(obj2));
6523 if (SWIG_arg_fail(3)) SWIG_fail;
6524 }
6525 {
6526 PyThreadState* __tstate = wxPyBeginAllowThreads();
6527 (arg1)->Move(arg2,arg3);
6528
6529 wxPyEndAllowThreads(__tstate);
6530 if (PyErr_Occurred()) SWIG_fail;
6531 }
6532 Py_INCREF(Py_None); resultobj = Py_None;
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj;
6541 wxCaret *arg1 = (wxCaret *) 0 ;
6542 wxPoint *arg2 = 0 ;
6543 wxPoint temp2 ;
6544 PyObject * obj0 = 0 ;
6545 PyObject * obj1 = 0 ;
6546 char *kwnames[] = {
6547 (char *) "self",(char *) "pt", NULL
6548 };
6549
6550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6552 if (SWIG_arg_fail(1)) SWIG_fail;
6553 {
6554 arg2 = &temp2;
6555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6556 }
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 (arg1)->Move((wxPoint const &)*arg2);
6560
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 Py_INCREF(Py_None); resultobj = Py_None;
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj;
6573 wxCaret *arg1 = (wxCaret *) 0 ;
6574 int arg2 ;
6575 int arg3 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 PyObject * obj2 = 0 ;
6579 char *kwnames[] = {
6580 (char *) "self",(char *) "width",(char *) "height", NULL
6581 };
6582
6583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6585 if (SWIG_arg_fail(1)) SWIG_fail;
6586 {
6587 arg2 = (int)(SWIG_As_int(obj1));
6588 if (SWIG_arg_fail(2)) SWIG_fail;
6589 }
6590 {
6591 arg3 = (int)(SWIG_As_int(obj2));
6592 if (SWIG_arg_fail(3)) SWIG_fail;
6593 }
6594 {
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 (arg1)->SetSize(arg2,arg3);
6597
6598 wxPyEndAllowThreads(__tstate);
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 Py_INCREF(Py_None); resultobj = Py_None;
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6609 PyObject *resultobj;
6610 wxCaret *arg1 = (wxCaret *) 0 ;
6611 wxSize *arg2 = 0 ;
6612 wxSize temp2 ;
6613 PyObject * obj0 = 0 ;
6614 PyObject * obj1 = 0 ;
6615 char *kwnames[] = {
6616 (char *) "self",(char *) "size", NULL
6617 };
6618
6619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6621 if (SWIG_arg_fail(1)) SWIG_fail;
6622 {
6623 arg2 = &temp2;
6624 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6625 }
6626 {
6627 PyThreadState* __tstate = wxPyBeginAllowThreads();
6628 (arg1)->SetSize((wxSize const &)*arg2);
6629
6630 wxPyEndAllowThreads(__tstate);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 Py_INCREF(Py_None); resultobj = Py_None;
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj;
6642 wxCaret *arg1 = (wxCaret *) 0 ;
6643 int arg2 = (int) true ;
6644 PyObject * obj0 = 0 ;
6645 PyObject * obj1 = 0 ;
6646 char *kwnames[] = {
6647 (char *) "self",(char *) "show", NULL
6648 };
6649
6650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6652 if (SWIG_arg_fail(1)) SWIG_fail;
6653 if (obj1) {
6654 {
6655 arg2 = (int)(SWIG_As_int(obj1));
6656 if (SWIG_arg_fail(2)) SWIG_fail;
6657 }
6658 }
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 (arg1)->Show(arg2);
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 Py_INCREF(Py_None); resultobj = Py_None;
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6674 PyObject *resultobj;
6675 wxCaret *arg1 = (wxCaret *) 0 ;
6676 PyObject * obj0 = 0 ;
6677 char *kwnames[] = {
6678 (char *) "self", NULL
6679 };
6680
6681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6683 if (SWIG_arg_fail(1)) SWIG_fail;
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 (arg1)->Hide();
6687
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 Py_INCREF(Py_None); resultobj = Py_None;
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6699 PyObject *resultobj;
6700 int result;
6701 char *kwnames[] = {
6702 NULL
6703 };
6704
6705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6706 {
6707 PyThreadState* __tstate = wxPyBeginAllowThreads();
6708 result = (int)wxCaret::GetBlinkTime();
6709
6710 wxPyEndAllowThreads(__tstate);
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 {
6714 resultobj = SWIG_From_int((int)(result));
6715 }
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj;
6724 int arg1 ;
6725 PyObject * obj0 = 0 ;
6726 char *kwnames[] = {
6727 (char *) "milliseconds", NULL
6728 };
6729
6730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6731 {
6732 arg1 = (int)(SWIG_As_int(obj0));
6733 if (SWIG_arg_fail(1)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 wxCaret::SetBlinkTime(arg1);
6738
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 Py_INCREF(Py_None); resultobj = Py_None;
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6750 PyObject *obj;
6751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6752 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6753 Py_INCREF(obj);
6754 return Py_BuildValue((char *)"");
6755 }
6756 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6757 PyObject *resultobj;
6758 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6759 wxBusyCursor *result;
6760 PyObject * obj0 = 0 ;
6761 char *kwnames[] = {
6762 (char *) "cursor", NULL
6763 };
6764
6765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6766 if (obj0) {
6767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6768 if (SWIG_arg_fail(1)) SWIG_fail;
6769 }
6770 {
6771 if (!wxPyCheckForApp()) SWIG_fail;
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6774
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6788 PyObject * obj0 = 0 ;
6789 char *kwnames[] = {
6790 (char *) "self", NULL
6791 };
6792
6793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6795 if (SWIG_arg_fail(1)) SWIG_fail;
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 delete arg1;
6799
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 Py_INCREF(Py_None); resultobj = Py_None;
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6811 PyObject *obj;
6812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6813 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6814 Py_INCREF(obj);
6815 return Py_BuildValue((char *)"");
6816 }
6817 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6818 PyObject *resultobj;
6819 wxWindow *arg1 = (wxWindow *) NULL ;
6820 wxWindowDisabler *result;
6821 PyObject * obj0 = 0 ;
6822 char *kwnames[] = {
6823 (char *) "winToSkip", NULL
6824 };
6825
6826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6827 if (obj0) {
6828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6829 if (SWIG_arg_fail(1)) SWIG_fail;
6830 }
6831 {
6832 if (!wxPyCheckForApp()) SWIG_fail;
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj;
6848 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6849 PyObject * obj0 = 0 ;
6850 char *kwnames[] = {
6851 (char *) "self", NULL
6852 };
6853
6854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6856 if (SWIG_arg_fail(1)) SWIG_fail;
6857 {
6858 PyThreadState* __tstate = wxPyBeginAllowThreads();
6859 delete arg1;
6860
6861 wxPyEndAllowThreads(__tstate);
6862 if (PyErr_Occurred()) SWIG_fail;
6863 }
6864 Py_INCREF(Py_None); resultobj = Py_None;
6865 return resultobj;
6866 fail:
6867 return NULL;
6868 }
6869
6870
6871 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6872 PyObject *obj;
6873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6874 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6875 Py_INCREF(obj);
6876 return Py_BuildValue((char *)"");
6877 }
6878 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6879 PyObject *resultobj;
6880 wxString *arg1 = 0 ;
6881 wxBusyInfo *result;
6882 bool temp1 = false ;
6883 PyObject * obj0 = 0 ;
6884 char *kwnames[] = {
6885 (char *) "message", NULL
6886 };
6887
6888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6889 {
6890 arg1 = wxString_in_helper(obj0);
6891 if (arg1 == NULL) SWIG_fail;
6892 temp1 = true;
6893 }
6894 {
6895 if (!wxPyCheckForApp()) SWIG_fail;
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6898
6899 wxPyEndAllowThreads(__tstate);
6900 if (PyErr_Occurred()) SWIG_fail;
6901 }
6902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6903 {
6904 if (temp1)
6905 delete arg1;
6906 }
6907 return resultobj;
6908 fail:
6909 {
6910 if (temp1)
6911 delete arg1;
6912 }
6913 return NULL;
6914 }
6915
6916
6917 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6918 PyObject *resultobj;
6919 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6920 PyObject * obj0 = 0 ;
6921 char *kwnames[] = {
6922 (char *) "self", NULL
6923 };
6924
6925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6927 if (SWIG_arg_fail(1)) SWIG_fail;
6928 {
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 delete arg1;
6931
6932 wxPyEndAllowThreads(__tstate);
6933 if (PyErr_Occurred()) SWIG_fail;
6934 }
6935 Py_INCREF(Py_None); resultobj = Py_None;
6936 return resultobj;
6937 fail:
6938 return NULL;
6939 }
6940
6941
6942 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6943 PyObject *obj;
6944 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6945 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6946 Py_INCREF(obj);
6947 return Py_BuildValue((char *)"");
6948 }
6949 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj;
6951 wxStopWatch *result;
6952 char *kwnames[] = {
6953 NULL
6954 };
6955
6956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6957 {
6958 PyThreadState* __tstate = wxPyBeginAllowThreads();
6959 result = (wxStopWatch *)new wxStopWatch();
6960
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj;
6973 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6974 long arg2 = (long) 0 ;
6975 PyObject * obj0 = 0 ;
6976 PyObject * obj1 = 0 ;
6977 char *kwnames[] = {
6978 (char *) "self",(char *) "t0", NULL
6979 };
6980
6981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6983 if (SWIG_arg_fail(1)) SWIG_fail;
6984 if (obj1) {
6985 {
6986 arg2 = (long)(SWIG_As_long(obj1));
6987 if (SWIG_arg_fail(2)) SWIG_fail;
6988 }
6989 }
6990 {
6991 PyThreadState* __tstate = wxPyBeginAllowThreads();
6992 (arg1)->Start(arg2);
6993
6994 wxPyEndAllowThreads(__tstate);
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 Py_INCREF(Py_None); resultobj = Py_None;
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7005 PyObject *resultobj;
7006 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7007 PyObject * obj0 = 0 ;
7008 char *kwnames[] = {
7009 (char *) "self", NULL
7010 };
7011
7012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7014 if (SWIG_arg_fail(1)) SWIG_fail;
7015 {
7016 PyThreadState* __tstate = wxPyBeginAllowThreads();
7017 (arg1)->Pause();
7018
7019 wxPyEndAllowThreads(__tstate);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 Py_INCREF(Py_None); resultobj = Py_None;
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj;
7031 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7032 PyObject * obj0 = 0 ;
7033 char *kwnames[] = {
7034 (char *) "self", NULL
7035 };
7036
7037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7039 if (SWIG_arg_fail(1)) SWIG_fail;
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 (arg1)->Resume();
7043
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 Py_INCREF(Py_None); resultobj = Py_None;
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj;
7056 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7057 long result;
7058 PyObject * obj0 = 0 ;
7059 char *kwnames[] = {
7060 (char *) "self", NULL
7061 };
7062
7063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7065 if (SWIG_arg_fail(1)) SWIG_fail;
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 result = (long)((wxStopWatch const *)arg1)->Time();
7069
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 {
7074 resultobj = SWIG_From_long((long)(result));
7075 }
7076 return resultobj;
7077 fail:
7078 return NULL;
7079 }
7080
7081
7082 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7083 PyObject *obj;
7084 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7085 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7086 Py_INCREF(obj);
7087 return Py_BuildValue((char *)"");
7088 }
7089 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 int arg1 = (int) 9 ;
7092 int arg2 = (int) wxID_FILE1 ;
7093 wxFileHistory *result;
7094 PyObject * obj0 = 0 ;
7095 PyObject * obj1 = 0 ;
7096 char *kwnames[] = {
7097 (char *) "maxFiles",(char *) "idBase", NULL
7098 };
7099
7100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7101 if (obj0) {
7102 {
7103 arg1 = (int)(SWIG_As_int(obj0));
7104 if (SWIG_arg_fail(1)) SWIG_fail;
7105 }
7106 }
7107 if (obj1) {
7108 {
7109 arg2 = (int)(SWIG_As_int(obj1));
7110 if (SWIG_arg_fail(2)) SWIG_fail;
7111 }
7112 }
7113 {
7114 PyThreadState* __tstate = wxPyBeginAllowThreads();
7115 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7116
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj;
7129 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7130 PyObject * obj0 = 0 ;
7131 char *kwnames[] = {
7132 (char *) "self", NULL
7133 };
7134
7135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7137 if (SWIG_arg_fail(1)) SWIG_fail;
7138 {
7139 PyThreadState* __tstate = wxPyBeginAllowThreads();
7140 delete arg1;
7141
7142 wxPyEndAllowThreads(__tstate);
7143 if (PyErr_Occurred()) SWIG_fail;
7144 }
7145 Py_INCREF(Py_None); resultobj = Py_None;
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7153 PyObject *resultobj;
7154 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7155 wxString *arg2 = 0 ;
7156 bool temp2 = false ;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self",(char *) "file", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 arg2 = wxString_in_helper(obj1);
7168 if (arg2 == NULL) SWIG_fail;
7169 temp2 = true;
7170 }
7171 {
7172 PyThreadState* __tstate = wxPyBeginAllowThreads();
7173 (arg1)->AddFileToHistory((wxString const &)*arg2);
7174
7175 wxPyEndAllowThreads(__tstate);
7176 if (PyErr_Occurred()) SWIG_fail;
7177 }
7178 Py_INCREF(Py_None); resultobj = Py_None;
7179 {
7180 if (temp2)
7181 delete arg2;
7182 }
7183 return resultobj;
7184 fail:
7185 {
7186 if (temp2)
7187 delete arg2;
7188 }
7189 return NULL;
7190 }
7191
7192
7193 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj;
7195 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7196 int arg2 ;
7197 PyObject * obj0 = 0 ;
7198 PyObject * obj1 = 0 ;
7199 char *kwnames[] = {
7200 (char *) "self",(char *) "i", NULL
7201 };
7202
7203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7205 if (SWIG_arg_fail(1)) SWIG_fail;
7206 {
7207 arg2 = (int)(SWIG_As_int(obj1));
7208 if (SWIG_arg_fail(2)) SWIG_fail;
7209 }
7210 {
7211 PyThreadState* __tstate = wxPyBeginAllowThreads();
7212 (arg1)->RemoveFileFromHistory(arg2);
7213
7214 wxPyEndAllowThreads(__tstate);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 Py_INCREF(Py_None); resultobj = Py_None;
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj;
7226 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7227 int result;
7228 PyObject * obj0 = 0 ;
7229 char *kwnames[] = {
7230 (char *) "self", NULL
7231 };
7232
7233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7235 if (SWIG_arg_fail(1)) SWIG_fail;
7236 {
7237 PyThreadState* __tstate = wxPyBeginAllowThreads();
7238 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7239
7240 wxPyEndAllowThreads(__tstate);
7241 if (PyErr_Occurred()) SWIG_fail;
7242 }
7243 {
7244 resultobj = SWIG_From_int((int)(result));
7245 }
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj;
7254 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7255 wxMenu *arg2 = (wxMenu *) 0 ;
7256 PyObject * obj0 = 0 ;
7257 PyObject * obj1 = 0 ;
7258 char *kwnames[] = {
7259 (char *) "self",(char *) "menu", NULL
7260 };
7261
7262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7264 if (SWIG_arg_fail(1)) SWIG_fail;
7265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7266 if (SWIG_arg_fail(2)) SWIG_fail;
7267 {
7268 PyThreadState* __tstate = wxPyBeginAllowThreads();
7269 (arg1)->UseMenu(arg2);
7270
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 Py_INCREF(Py_None); resultobj = Py_None;
7275 return resultobj;
7276 fail:
7277 return NULL;
7278 }
7279
7280
7281 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7282 PyObject *resultobj;
7283 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7284 wxMenu *arg2 = (wxMenu *) 0 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char *kwnames[] = {
7288 (char *) "self",(char *) "menu", NULL
7289 };
7290
7291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7293 if (SWIG_arg_fail(1)) SWIG_fail;
7294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7295 if (SWIG_arg_fail(2)) SWIG_fail;
7296 {
7297 PyThreadState* __tstate = wxPyBeginAllowThreads();
7298 (arg1)->RemoveMenu(arg2);
7299
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 Py_INCREF(Py_None); resultobj = Py_None;
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj;
7312 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7313 wxConfigBase *arg2 = 0 ;
7314 PyObject * obj0 = 0 ;
7315 PyObject * obj1 = 0 ;
7316 char *kwnames[] = {
7317 (char *) "self",(char *) "config", NULL
7318 };
7319
7320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7322 if (SWIG_arg_fail(1)) SWIG_fail;
7323 {
7324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7325 if (SWIG_arg_fail(2)) SWIG_fail;
7326 if (arg2 == NULL) {
7327 SWIG_null_ref("wxConfigBase");
7328 }
7329 if (SWIG_arg_fail(2)) SWIG_fail;
7330 }
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 (arg1)->Load(*arg2);
7334
7335 wxPyEndAllowThreads(__tstate);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 Py_INCREF(Py_None); resultobj = Py_None;
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj;
7347 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7348 wxConfigBase *arg2 = 0 ;
7349 PyObject * obj0 = 0 ;
7350 PyObject * obj1 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self",(char *) "config", NULL
7353 };
7354
7355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7357 if (SWIG_arg_fail(1)) SWIG_fail;
7358 {
7359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7360 if (SWIG_arg_fail(2)) SWIG_fail;
7361 if (arg2 == NULL) {
7362 SWIG_null_ref("wxConfigBase");
7363 }
7364 if (SWIG_arg_fail(2)) SWIG_fail;
7365 }
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 (arg1)->Save(*arg2);
7369
7370 wxPyEndAllowThreads(__tstate);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 Py_INCREF(Py_None); resultobj = Py_None;
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7381 PyObject *resultobj;
7382 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(1)) SWIG_fail;
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 (arg1)->AddFilesToMenu();
7394
7395 wxPyEndAllowThreads(__tstate);
7396 if (PyErr_Occurred()) SWIG_fail;
7397 }
7398 Py_INCREF(Py_None); resultobj = Py_None;
7399 return resultobj;
7400 fail:
7401 return NULL;
7402 }
7403
7404
7405 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7406 PyObject *resultobj;
7407 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7408 wxMenu *arg2 = (wxMenu *) 0 ;
7409 PyObject * obj0 = 0 ;
7410 PyObject * obj1 = 0 ;
7411 char *kwnames[] = {
7412 (char *) "self",(char *) "menu", NULL
7413 };
7414
7415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7417 if (SWIG_arg_fail(1)) SWIG_fail;
7418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(2)) SWIG_fail;
7420 {
7421 PyThreadState* __tstate = wxPyBeginAllowThreads();
7422 (arg1)->AddFilesToMenu(arg2);
7423
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 Py_INCREF(Py_None); resultobj = Py_None;
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj;
7436 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7437 int arg2 ;
7438 wxString result;
7439 PyObject * obj0 = 0 ;
7440 PyObject * obj1 = 0 ;
7441 char *kwnames[] = {
7442 (char *) "self",(char *) "i", NULL
7443 };
7444
7445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7447 if (SWIG_arg_fail(1)) SWIG_fail;
7448 {
7449 arg2 = (int)(SWIG_As_int(obj1));
7450 if (SWIG_arg_fail(2)) SWIG_fail;
7451 }
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7455
7456 wxPyEndAllowThreads(__tstate);
7457 if (PyErr_Occurred()) SWIG_fail;
7458 }
7459 {
7460 #if wxUSE_UNICODE
7461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7462 #else
7463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7464 #endif
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7473 PyObject *resultobj;
7474 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7475 int result;
7476 PyObject * obj0 = 0 ;
7477 char *kwnames[] = {
7478 (char *) "self", NULL
7479 };
7480
7481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7483 if (SWIG_arg_fail(1)) SWIG_fail;
7484 {
7485 PyThreadState* __tstate = wxPyBeginAllowThreads();
7486 result = (int)((wxFileHistory const *)arg1)->GetCount();
7487
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 {
7492 resultobj = SWIG_From_int((int)(result));
7493 }
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7501 PyObject *obj;
7502 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7503 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7504 Py_INCREF(obj);
7505 return Py_BuildValue((char *)"");
7506 }
7507 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7508 PyObject *resultobj;
7509 wxString *arg1 = 0 ;
7510 wxString const &arg2_defvalue = wxPyEmptyString ;
7511 wxString *arg2 = (wxString *) &arg2_defvalue ;
7512 wxSingleInstanceChecker *result;
7513 bool temp1 = false ;
7514 bool temp2 = false ;
7515 PyObject * obj0 = 0 ;
7516 PyObject * obj1 = 0 ;
7517 char *kwnames[] = {
7518 (char *) "name",(char *) "path", NULL
7519 };
7520
7521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7522 {
7523 arg1 = wxString_in_helper(obj0);
7524 if (arg1 == NULL) SWIG_fail;
7525 temp1 = true;
7526 }
7527 if (obj1) {
7528 {
7529 arg2 = wxString_in_helper(obj1);
7530 if (arg2 == NULL) SWIG_fail;
7531 temp2 = true;
7532 }
7533 }
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7537
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7542 {
7543 if (temp1)
7544 delete arg1;
7545 }
7546 {
7547 if (temp2)
7548 delete arg2;
7549 }
7550 return resultobj;
7551 fail:
7552 {
7553 if (temp1)
7554 delete arg1;
7555 }
7556 {
7557 if (temp2)
7558 delete arg2;
7559 }
7560 return NULL;
7561 }
7562
7563
7564 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj;
7566 wxSingleInstanceChecker *result;
7567 char *kwnames[] = {
7568 NULL
7569 };
7570
7571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7575
7576 wxPyEndAllowThreads(__tstate);
7577 if (PyErr_Occurred()) SWIG_fail;
7578 }
7579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7580 return resultobj;
7581 fail:
7582 return NULL;
7583 }
7584
7585
7586 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7587 PyObject *resultobj;
7588 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7589 PyObject * obj0 = 0 ;
7590 char *kwnames[] = {
7591 (char *) "self", NULL
7592 };
7593
7594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7596 if (SWIG_arg_fail(1)) SWIG_fail;
7597 {
7598 PyThreadState* __tstate = wxPyBeginAllowThreads();
7599 delete arg1;
7600
7601 wxPyEndAllowThreads(__tstate);
7602 if (PyErr_Occurred()) SWIG_fail;
7603 }
7604 Py_INCREF(Py_None); resultobj = Py_None;
7605 return resultobj;
7606 fail:
7607 return NULL;
7608 }
7609
7610
7611 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7612 PyObject *resultobj;
7613 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7614 wxString *arg2 = 0 ;
7615 wxString const &arg3_defvalue = wxPyEmptyString ;
7616 wxString *arg3 = (wxString *) &arg3_defvalue ;
7617 bool result;
7618 bool temp2 = false ;
7619 bool temp3 = false ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 PyObject * obj2 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "self",(char *) "name",(char *) "path", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7629 if (SWIG_arg_fail(1)) SWIG_fail;
7630 {
7631 arg2 = wxString_in_helper(obj1);
7632 if (arg2 == NULL) SWIG_fail;
7633 temp2 = true;
7634 }
7635 if (obj2) {
7636 {
7637 arg3 = wxString_in_helper(obj2);
7638 if (arg3 == NULL) SWIG_fail;
7639 temp3 = true;
7640 }
7641 }
7642 {
7643 PyThreadState* __tstate = wxPyBeginAllowThreads();
7644 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7645
7646 wxPyEndAllowThreads(__tstate);
7647 if (PyErr_Occurred()) SWIG_fail;
7648 }
7649 {
7650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7651 }
7652 {
7653 if (temp2)
7654 delete arg2;
7655 }
7656 {
7657 if (temp3)
7658 delete arg3;
7659 }
7660 return resultobj;
7661 fail:
7662 {
7663 if (temp2)
7664 delete arg2;
7665 }
7666 {
7667 if (temp3)
7668 delete arg3;
7669 }
7670 return NULL;
7671 }
7672
7673
7674 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj;
7676 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7677 bool result;
7678 PyObject * obj0 = 0 ;
7679 char *kwnames[] = {
7680 (char *) "self", NULL
7681 };
7682
7683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7685 if (SWIG_arg_fail(1)) SWIG_fail;
7686 {
7687 PyThreadState* __tstate = wxPyBeginAllowThreads();
7688 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7689
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7703 PyObject *obj;
7704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7705 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7706 Py_INCREF(obj);
7707 return Py_BuildValue((char *)"");
7708 }
7709 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7710 PyObject *resultobj;
7711 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7712 PyObject * obj0 = 0 ;
7713 char *kwnames[] = {
7714 (char *) "self", NULL
7715 };
7716
7717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7719 if (SWIG_arg_fail(1)) SWIG_fail;
7720 {
7721 PyThreadState* __tstate = wxPyBeginAllowThreads();
7722 delete arg1;
7723
7724 wxPyEndAllowThreads(__tstate);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 Py_INCREF(Py_None); resultobj = Py_None;
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7735 PyObject *resultobj;
7736 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7737 wxString result;
7738 PyObject * obj0 = 0 ;
7739 char *kwnames[] = {
7740 (char *) "self", NULL
7741 };
7742
7743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7745 if (SWIG_arg_fail(1)) SWIG_fail;
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 result = (arg1)->GetTip();
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 #if wxUSE_UNICODE
7755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7756 #else
7757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7758 #endif
7759 }
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj;
7768 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7769 size_t result;
7770 PyObject * obj0 = 0 ;
7771 char *kwnames[] = {
7772 (char *) "self", NULL
7773 };
7774
7775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7777 if (SWIG_arg_fail(1)) SWIG_fail;
7778 {
7779 PyThreadState* __tstate = wxPyBeginAllowThreads();
7780 result = (size_t)(arg1)->GetCurrentTip();
7781
7782 wxPyEndAllowThreads(__tstate);
7783 if (PyErr_Occurred()) SWIG_fail;
7784 }
7785 {
7786 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7787 }
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7795 PyObject *resultobj;
7796 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7797 wxString *arg2 = 0 ;
7798 wxString result;
7799 bool temp2 = false ;
7800 PyObject * obj0 = 0 ;
7801 PyObject * obj1 = 0 ;
7802 char *kwnames[] = {
7803 (char *) "self",(char *) "tip", NULL
7804 };
7805
7806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7808 if (SWIG_arg_fail(1)) SWIG_fail;
7809 {
7810 arg2 = wxString_in_helper(obj1);
7811 if (arg2 == NULL) SWIG_fail;
7812 temp2 = true;
7813 }
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7817
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 #if wxUSE_UNICODE
7823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7824 #else
7825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7826 #endif
7827 }
7828 {
7829 if (temp2)
7830 delete arg2;
7831 }
7832 return resultobj;
7833 fail:
7834 {
7835 if (temp2)
7836 delete arg2;
7837 }
7838 return NULL;
7839 }
7840
7841
7842 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7843 PyObject *obj;
7844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7845 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7846 Py_INCREF(obj);
7847 return Py_BuildValue((char *)"");
7848 }
7849 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7850 PyObject *resultobj;
7851 size_t arg1 ;
7852 wxPyTipProvider *result;
7853 PyObject * obj0 = 0 ;
7854 char *kwnames[] = {
7855 (char *) "currentTip", NULL
7856 };
7857
7858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7859 {
7860 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 }
7863 {
7864 PyThreadState* __tstate = wxPyBeginAllowThreads();
7865 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7866
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj;
7879 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7880 PyObject *arg2 = (PyObject *) 0 ;
7881 PyObject *arg3 = (PyObject *) 0 ;
7882 PyObject * obj0 = 0 ;
7883 PyObject * obj1 = 0 ;
7884 PyObject * obj2 = 0 ;
7885 char *kwnames[] = {
7886 (char *) "self",(char *) "self",(char *) "_class", NULL
7887 };
7888
7889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7891 if (SWIG_arg_fail(1)) SWIG_fail;
7892 arg2 = obj1;
7893 arg3 = obj2;
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 (arg1)->_setCallbackInfo(arg2,arg3);
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 Py_INCREF(Py_None); resultobj = Py_None;
7902 return resultobj;
7903 fail:
7904 return NULL;
7905 }
7906
7907
7908 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7909 PyObject *obj;
7910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7911 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7912 Py_INCREF(obj);
7913 return Py_BuildValue((char *)"");
7914 }
7915 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7916 PyObject *resultobj;
7917 wxWindow *arg1 = (wxWindow *) 0 ;
7918 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7919 bool arg3 = (bool) true ;
7920 bool result;
7921 PyObject * obj0 = 0 ;
7922 PyObject * obj1 = 0 ;
7923 PyObject * obj2 = 0 ;
7924 char *kwnames[] = {
7925 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7926 };
7927
7928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7930 if (SWIG_arg_fail(1)) SWIG_fail;
7931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(2)) SWIG_fail;
7933 if (obj2) {
7934 {
7935 arg3 = (bool)(SWIG_As_bool(obj2));
7936 if (SWIG_arg_fail(3)) SWIG_fail;
7937 }
7938 }
7939 {
7940 if (!wxPyCheckForApp()) SWIG_fail;
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (bool)wxShowTip(arg1,arg2,arg3);
7943
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 {
7948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7949 }
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj;
7958 wxString *arg1 = 0 ;
7959 size_t arg2 ;
7960 wxTipProvider *result;
7961 bool temp1 = false ;
7962 PyObject * obj0 = 0 ;
7963 PyObject * obj1 = 0 ;
7964 char *kwnames[] = {
7965 (char *) "filename",(char *) "currentTip", NULL
7966 };
7967
7968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7969 {
7970 arg1 = wxString_in_helper(obj0);
7971 if (arg1 == NULL) SWIG_fail;
7972 temp1 = true;
7973 }
7974 {
7975 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7976 if (SWIG_arg_fail(2)) SWIG_fail;
7977 }
7978 {
7979 if (!wxPyCheckForApp()) SWIG_fail;
7980 PyThreadState* __tstate = wxPyBeginAllowThreads();
7981 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7982
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7987 {
7988 if (temp1)
7989 delete arg1;
7990 }
7991 return resultobj;
7992 fail:
7993 {
7994 if (temp1)
7995 delete arg1;
7996 }
7997 return NULL;
7998 }
7999
8000
8001 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8002 PyObject *resultobj;
8003 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8004 int arg2 = (int) -1 ;
8005 wxPyTimer *result;
8006 PyObject * obj0 = 0 ;
8007 PyObject * obj1 = 0 ;
8008 char *kwnames[] = {
8009 (char *) "owner",(char *) "id", NULL
8010 };
8011
8012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8013 if (obj0) {
8014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8015 if (SWIG_arg_fail(1)) SWIG_fail;
8016 }
8017 if (obj1) {
8018 {
8019 arg2 = (int)(SWIG_As_int(obj1));
8020 if (SWIG_arg_fail(2)) SWIG_fail;
8021 }
8022 }
8023 {
8024 if (!wxPyCheckForApp()) SWIG_fail;
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8027
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8039 PyObject *resultobj;
8040 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8041 PyObject * obj0 = 0 ;
8042 char *kwnames[] = {
8043 (char *) "self", NULL
8044 };
8045
8046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8048 if (SWIG_arg_fail(1)) SWIG_fail;
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 delete arg1;
8052
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 Py_INCREF(Py_None); resultobj = Py_None;
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8064 PyObject *resultobj;
8065 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8066 PyObject *arg2 = (PyObject *) 0 ;
8067 PyObject *arg3 = (PyObject *) 0 ;
8068 int arg4 = (int) 1 ;
8069 PyObject * obj0 = 0 ;
8070 PyObject * obj1 = 0 ;
8071 PyObject * obj2 = 0 ;
8072 PyObject * obj3 = 0 ;
8073 char *kwnames[] = {
8074 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8075 };
8076
8077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8079 if (SWIG_arg_fail(1)) SWIG_fail;
8080 arg2 = obj1;
8081 arg3 = obj2;
8082 if (obj3) {
8083 {
8084 arg4 = (int)(SWIG_As_int(obj3));
8085 if (SWIG_arg_fail(4)) SWIG_fail;
8086 }
8087 }
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 Py_INCREF(Py_None); resultobj = Py_None;
8096 return resultobj;
8097 fail:
8098 return NULL;
8099 }
8100
8101
8102 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8103 PyObject *resultobj;
8104 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8105 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8106 int arg3 = (int) -1 ;
8107 PyObject * obj0 = 0 ;
8108 PyObject * obj1 = 0 ;
8109 PyObject * obj2 = 0 ;
8110 char *kwnames[] = {
8111 (char *) "self",(char *) "owner",(char *) "id", NULL
8112 };
8113
8114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8116 if (SWIG_arg_fail(1)) SWIG_fail;
8117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8118 if (SWIG_arg_fail(2)) SWIG_fail;
8119 if (obj2) {
8120 {
8121 arg3 = (int)(SWIG_As_int(obj2));
8122 if (SWIG_arg_fail(3)) SWIG_fail;
8123 }
8124 }
8125 {
8126 PyThreadState* __tstate = wxPyBeginAllowThreads();
8127 (arg1)->SetOwner(arg2,arg3);
8128
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 Py_INCREF(Py_None); resultobj = Py_None;
8133 return resultobj;
8134 fail:
8135 return NULL;
8136 }
8137
8138
8139 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8140 PyObject *resultobj;
8141 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8142 wxEvtHandler *result;
8143 PyObject * obj0 = 0 ;
8144 char *kwnames[] = {
8145 (char *) "self", NULL
8146 };
8147
8148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8150 if (SWIG_arg_fail(1)) SWIG_fail;
8151 {
8152 PyThreadState* __tstate = wxPyBeginAllowThreads();
8153 result = (wxEvtHandler *)(arg1)->GetOwner();
8154
8155 wxPyEndAllowThreads(__tstate);
8156 if (PyErr_Occurred()) SWIG_fail;
8157 }
8158 {
8159 resultobj = wxPyMake_wxObject(result, 0);
8160 }
8161 return resultobj;
8162 fail:
8163 return NULL;
8164 }
8165
8166
8167 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj;
8169 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8170 int arg2 = (int) -1 ;
8171 bool arg3 = (bool) false ;
8172 bool result;
8173 PyObject * obj0 = 0 ;
8174 PyObject * obj1 = 0 ;
8175 PyObject * obj2 = 0 ;
8176 char *kwnames[] = {
8177 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8178 };
8179
8180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8182 if (SWIG_arg_fail(1)) SWIG_fail;
8183 if (obj1) {
8184 {
8185 arg2 = (int)(SWIG_As_int(obj1));
8186 if (SWIG_arg_fail(2)) SWIG_fail;
8187 }
8188 }
8189 if (obj2) {
8190 {
8191 arg3 = (bool)(SWIG_As_bool(obj2));
8192 if (SWIG_arg_fail(3)) SWIG_fail;
8193 }
8194 }
8195 {
8196 PyThreadState* __tstate = wxPyBeginAllowThreads();
8197 result = (bool)(arg1)->Start(arg2,arg3);
8198
8199 wxPyEndAllowThreads(__tstate);
8200 if (PyErr_Occurred()) SWIG_fail;
8201 }
8202 {
8203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8204 }
8205 return resultobj;
8206 fail:
8207 return NULL;
8208 }
8209
8210
8211 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8212 PyObject *resultobj;
8213 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8214 PyObject * obj0 = 0 ;
8215 char *kwnames[] = {
8216 (char *) "self", NULL
8217 };
8218
8219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8221 if (SWIG_arg_fail(1)) SWIG_fail;
8222 {
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 (arg1)->Stop();
8225
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 Py_INCREF(Py_None); resultobj = Py_None;
8230 return resultobj;
8231 fail:
8232 return NULL;
8233 }
8234
8235
8236 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8237 PyObject *resultobj;
8238 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8239 bool result;
8240 PyObject * obj0 = 0 ;
8241 char *kwnames[] = {
8242 (char *) "self", NULL
8243 };
8244
8245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8247 if (SWIG_arg_fail(1)) SWIG_fail;
8248 {
8249 PyThreadState* __tstate = wxPyBeginAllowThreads();
8250 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8251
8252 wxPyEndAllowThreads(__tstate);
8253 if (PyErr_Occurred()) SWIG_fail;
8254 }
8255 {
8256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8257 }
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8267 int result;
8268 PyObject * obj0 = 0 ;
8269 char *kwnames[] = {
8270 (char *) "self", NULL
8271 };
8272
8273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8275 if (SWIG_arg_fail(1)) SWIG_fail;
8276 {
8277 PyThreadState* __tstate = wxPyBeginAllowThreads();
8278 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8279
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 {
8284 resultobj = SWIG_From_int((int)(result));
8285 }
8286 return resultobj;
8287 fail:
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj;
8294 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8295 bool result;
8296 PyObject * obj0 = 0 ;
8297 char *kwnames[] = {
8298 (char *) "self", NULL
8299 };
8300
8301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8303 if (SWIG_arg_fail(1)) SWIG_fail;
8304 {
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8307
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 {
8312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8313 }
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8321 PyObject *resultobj;
8322 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8323 int result;
8324 PyObject * obj0 = 0 ;
8325 char *kwnames[] = {
8326 (char *) "self", NULL
8327 };
8328
8329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8331 if (SWIG_arg_fail(1)) SWIG_fail;
8332 {
8333 PyThreadState* __tstate = wxPyBeginAllowThreads();
8334 result = (int)((wxPyTimer const *)arg1)->GetId();
8335
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 {
8340 resultobj = SWIG_From_int((int)(result));
8341 }
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8349 PyObject *obj;
8350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8351 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8352 Py_INCREF(obj);
8353 return Py_BuildValue((char *)"");
8354 }
8355 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj;
8357 int arg1 = (int) 0 ;
8358 int arg2 = (int) 0 ;
8359 wxTimerEvent *result;
8360 PyObject * obj0 = 0 ;
8361 PyObject * obj1 = 0 ;
8362 char *kwnames[] = {
8363 (char *) "timerid",(char *) "interval", NULL
8364 };
8365
8366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8367 if (obj0) {
8368 {
8369 arg1 = (int)(SWIG_As_int(obj0));
8370 if (SWIG_arg_fail(1)) SWIG_fail;
8371 }
8372 }
8373 if (obj1) {
8374 {
8375 arg2 = (int)(SWIG_As_int(obj1));
8376 if (SWIG_arg_fail(2)) SWIG_fail;
8377 }
8378 }
8379 {
8380 PyThreadState* __tstate = wxPyBeginAllowThreads();
8381 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8382
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj;
8395 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8396 int result;
8397 PyObject * obj0 = 0 ;
8398 char *kwnames[] = {
8399 (char *) "self", NULL
8400 };
8401
8402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8404 if (SWIG_arg_fail(1)) SWIG_fail;
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 {
8413 resultobj = SWIG_From_int((int)(result));
8414 }
8415 return resultobj;
8416 fail:
8417 return NULL;
8418 }
8419
8420
8421 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8422 PyObject *obj;
8423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8424 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8425 Py_INCREF(obj);
8426 return Py_BuildValue((char *)"");
8427 }
8428 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8429 PyObject *resultobj;
8430 wxTimer *arg1 = 0 ;
8431 wxTimerRunner *result;
8432 PyObject * obj0 = 0 ;
8433
8434 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8435 {
8436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8437 if (SWIG_arg_fail(1)) SWIG_fail;
8438 if (arg1 == NULL) {
8439 SWIG_null_ref("wxTimer");
8440 }
8441 if (SWIG_arg_fail(1)) SWIG_fail;
8442 }
8443 {
8444 if (!wxPyCheckForApp()) SWIG_fail;
8445 PyThreadState* __tstate = wxPyBeginAllowThreads();
8446 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8447
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8459 PyObject *resultobj;
8460 wxTimer *arg1 = 0 ;
8461 int arg2 ;
8462 bool arg3 = (bool) false ;
8463 wxTimerRunner *result;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 PyObject * obj2 = 0 ;
8467
8468 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8469 {
8470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8471 if (SWIG_arg_fail(1)) SWIG_fail;
8472 if (arg1 == NULL) {
8473 SWIG_null_ref("wxTimer");
8474 }
8475 if (SWIG_arg_fail(1)) SWIG_fail;
8476 }
8477 {
8478 arg2 = (int)(SWIG_As_int(obj1));
8479 if (SWIG_arg_fail(2)) SWIG_fail;
8480 }
8481 if (obj2) {
8482 {
8483 arg3 = (bool)(SWIG_As_bool(obj2));
8484 if (SWIG_arg_fail(3)) SWIG_fail;
8485 }
8486 }
8487 {
8488 if (!wxPyCheckForApp()) SWIG_fail;
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8491
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8503 int argc;
8504 PyObject *argv[4];
8505 int ii;
8506
8507 argc = PyObject_Length(args);
8508 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8509 argv[ii] = PyTuple_GetItem(args,ii);
8510 }
8511 if (argc == 1) {
8512 int _v;
8513 {
8514 void *ptr = 0;
8515 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8516 _v = 0;
8517 PyErr_Clear();
8518 } else {
8519 _v = (ptr != 0);
8520 }
8521 }
8522 if (_v) {
8523 return _wrap_new_TimerRunner__SWIG_0(self,args);
8524 }
8525 }
8526 if ((argc >= 2) && (argc <= 3)) {
8527 int _v;
8528 {
8529 void *ptr = 0;
8530 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8531 _v = 0;
8532 PyErr_Clear();
8533 } else {
8534 _v = (ptr != 0);
8535 }
8536 }
8537 if (_v) {
8538 _v = SWIG_Check_int(argv[1]);
8539 if (_v) {
8540 if (argc <= 2) {
8541 return _wrap_new_TimerRunner__SWIG_1(self,args);
8542 }
8543 _v = SWIG_Check_bool(argv[2]);
8544 if (_v) {
8545 return _wrap_new_TimerRunner__SWIG_1(self,args);
8546 }
8547 }
8548 }
8549 }
8550
8551 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8552 return NULL;
8553 }
8554
8555
8556 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj;
8558 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8559 PyObject * obj0 = 0 ;
8560 char *kwnames[] = {
8561 (char *) "self", NULL
8562 };
8563
8564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8566 if (SWIG_arg_fail(1)) SWIG_fail;
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 delete arg1;
8570
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 Py_INCREF(Py_None); resultobj = Py_None;
8575 return resultobj;
8576 fail:
8577 return NULL;
8578 }
8579
8580
8581 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8582 PyObject *resultobj;
8583 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8584 int arg2 ;
8585 bool arg3 = (bool) false ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 PyObject * obj2 = 0 ;
8589 char *kwnames[] = {
8590 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8591 };
8592
8593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8595 if (SWIG_arg_fail(1)) SWIG_fail;
8596 {
8597 arg2 = (int)(SWIG_As_int(obj1));
8598 if (SWIG_arg_fail(2)) SWIG_fail;
8599 }
8600 if (obj2) {
8601 {
8602 arg3 = (bool)(SWIG_As_bool(obj2));
8603 if (SWIG_arg_fail(3)) SWIG_fail;
8604 }
8605 }
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 (arg1)->Start(arg2,arg3);
8609
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 Py_INCREF(Py_None); resultobj = Py_None;
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8621 PyObject *obj;
8622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8623 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8624 Py_INCREF(obj);
8625 return Py_BuildValue((char *)"");
8626 }
8627 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8628 PyObject *resultobj;
8629 wxLog *result;
8630 char *kwnames[] = {
8631 NULL
8632 };
8633
8634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8635 {
8636 PyThreadState* __tstate = wxPyBeginAllowThreads();
8637 result = (wxLog *)new wxLog();
8638
8639 wxPyEndAllowThreads(__tstate);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj;
8651 bool result;
8652 char *kwnames[] = {
8653 NULL
8654 };
8655
8656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (bool)wxLog::IsEnabled();
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 {
8665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8666 }
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj;
8675 bool arg1 = (bool) true ;
8676 bool result;
8677 PyObject * obj0 = 0 ;
8678 char *kwnames[] = {
8679 (char *) "doIt", NULL
8680 };
8681
8682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8683 if (obj0) {
8684 {
8685 arg1 = (bool)(SWIG_As_bool(obj0));
8686 if (SWIG_arg_fail(1)) SWIG_fail;
8687 }
8688 }
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 result = (bool)wxLog::EnableLogging(arg1);
8692
8693 wxPyEndAllowThreads(__tstate);
8694 if (PyErr_Occurred()) SWIG_fail;
8695 }
8696 {
8697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8698 }
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj;
8707 wxLogLevel arg1 ;
8708 wxChar *arg2 = (wxChar *) 0 ;
8709 time_t arg3 ;
8710 PyObject * obj0 = 0 ;
8711 PyObject * obj1 = 0 ;
8712 PyObject * obj2 = 0 ;
8713 char *kwnames[] = {
8714 (char *) "level",(char *) "szString",(char *) "t", NULL
8715 };
8716
8717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8718 {
8719 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8720 if (SWIG_arg_fail(1)) SWIG_fail;
8721 }
8722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8723 if (SWIG_arg_fail(2)) SWIG_fail;
8724 {
8725 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8726 if (SWIG_arg_fail(3)) SWIG_fail;
8727 }
8728 {
8729 PyThreadState* __tstate = wxPyBeginAllowThreads();
8730 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8731
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 Py_INCREF(Py_None); resultobj = Py_None;
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj;
8744 wxLog *arg1 = (wxLog *) 0 ;
8745 PyObject * obj0 = 0 ;
8746 char *kwnames[] = {
8747 (char *) "self", NULL
8748 };
8749
8750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8752 if (SWIG_arg_fail(1)) SWIG_fail;
8753 {
8754 PyThreadState* __tstate = wxPyBeginAllowThreads();
8755 (arg1)->Flush();
8756
8757 wxPyEndAllowThreads(__tstate);
8758 if (PyErr_Occurred()) SWIG_fail;
8759 }
8760 Py_INCREF(Py_None); resultobj = Py_None;
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj;
8769 char *kwnames[] = {
8770 NULL
8771 };
8772
8773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8774 {
8775 PyThreadState* __tstate = wxPyBeginAllowThreads();
8776 wxLog::FlushActive();
8777
8778 wxPyEndAllowThreads(__tstate);
8779 if (PyErr_Occurred()) SWIG_fail;
8780 }
8781 Py_INCREF(Py_None); resultobj = Py_None;
8782 return resultobj;
8783 fail:
8784 return NULL;
8785 }
8786
8787
8788 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8789 PyObject *resultobj;
8790 wxLog *result;
8791 char *kwnames[] = {
8792 NULL
8793 };
8794
8795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8796 {
8797 PyThreadState* __tstate = wxPyBeginAllowThreads();
8798 result = (wxLog *)wxLog::GetActiveTarget();
8799
8800 wxPyEndAllowThreads(__tstate);
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8804 return resultobj;
8805 fail:
8806 return NULL;
8807 }
8808
8809
8810 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj;
8812 wxLog *arg1 = (wxLog *) 0 ;
8813 wxLog *result;
8814 PyObject * obj0 = 0 ;
8815 char *kwnames[] = {
8816 (char *) "pLogger", NULL
8817 };
8818
8819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8821 if (SWIG_arg_fail(1)) SWIG_fail;
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8825
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj;
8838 char *kwnames[] = {
8839 NULL
8840 };
8841
8842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 wxLog::Suspend();
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 Py_INCREF(Py_None); resultobj = Py_None;
8851 return resultobj;
8852 fail:
8853 return NULL;
8854 }
8855
8856
8857 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8858 PyObject *resultobj;
8859 char *kwnames[] = {
8860 NULL
8861 };
8862
8863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 wxLog::Resume();
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 Py_INCREF(Py_None); resultobj = Py_None;
8872 return resultobj;
8873 fail:
8874 return NULL;
8875 }
8876
8877
8878 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8879 PyObject *resultobj;
8880 bool arg1 = (bool) true ;
8881 PyObject * obj0 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "bVerbose", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8887 if (obj0) {
8888 {
8889 arg1 = (bool)(SWIG_As_bool(obj0));
8890 if (SWIG_arg_fail(1)) SWIG_fail;
8891 }
8892 }
8893 {
8894 PyThreadState* __tstate = wxPyBeginAllowThreads();
8895 wxLog::SetVerbose(arg1);
8896
8897 wxPyEndAllowThreads(__tstate);
8898 if (PyErr_Occurred()) SWIG_fail;
8899 }
8900 Py_INCREF(Py_None); resultobj = Py_None;
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj;
8909 wxLogLevel arg1 ;
8910 PyObject * obj0 = 0 ;
8911 char *kwnames[] = {
8912 (char *) "logLevel", NULL
8913 };
8914
8915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8916 {
8917 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 }
8920 {
8921 PyThreadState* __tstate = wxPyBeginAllowThreads();
8922 wxLog::SetLogLevel(arg1);
8923
8924 wxPyEndAllowThreads(__tstate);
8925 if (PyErr_Occurred()) SWIG_fail;
8926 }
8927 Py_INCREF(Py_None); resultobj = Py_None;
8928 return resultobj;
8929 fail:
8930 return NULL;
8931 }
8932
8933
8934 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8935 PyObject *resultobj;
8936 char *kwnames[] = {
8937 NULL
8938 };
8939
8940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8941 {
8942 PyThreadState* __tstate = wxPyBeginAllowThreads();
8943 wxLog::DontCreateOnDemand();
8944
8945 wxPyEndAllowThreads(__tstate);
8946 if (PyErr_Occurred()) SWIG_fail;
8947 }
8948 Py_INCREF(Py_None); resultobj = Py_None;
8949 return resultobj;
8950 fail:
8951 return NULL;
8952 }
8953
8954
8955 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj;
8957 wxTraceMask arg1 ;
8958 PyObject * obj0 = 0 ;
8959 char *kwnames[] = {
8960 (char *) "ulMask", NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8964 {
8965 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8966 if (SWIG_arg_fail(1)) SWIG_fail;
8967 }
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 wxLog::SetTraceMask(arg1);
8971
8972 wxPyEndAllowThreads(__tstate);
8973 if (PyErr_Occurred()) SWIG_fail;
8974 }
8975 Py_INCREF(Py_None); resultobj = Py_None;
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj;
8984 wxString *arg1 = 0 ;
8985 bool temp1 = false ;
8986 PyObject * obj0 = 0 ;
8987 char *kwnames[] = {
8988 (char *) "str", NULL
8989 };
8990
8991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8992 {
8993 arg1 = wxString_in_helper(obj0);
8994 if (arg1 == NULL) SWIG_fail;
8995 temp1 = true;
8996 }
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 wxLog::AddTraceMask((wxString const &)*arg1);
9000
9001 wxPyEndAllowThreads(__tstate);
9002 if (PyErr_Occurred()) SWIG_fail;
9003 }
9004 Py_INCREF(Py_None); resultobj = Py_None;
9005 {
9006 if (temp1)
9007 delete arg1;
9008 }
9009 return resultobj;
9010 fail:
9011 {
9012 if (temp1)
9013 delete arg1;
9014 }
9015 return NULL;
9016 }
9017
9018
9019 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj;
9021 wxString *arg1 = 0 ;
9022 bool temp1 = false ;
9023 PyObject * obj0 = 0 ;
9024 char *kwnames[] = {
9025 (char *) "str", NULL
9026 };
9027
9028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9029 {
9030 arg1 = wxString_in_helper(obj0);
9031 if (arg1 == NULL) SWIG_fail;
9032 temp1 = true;
9033 }
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 wxLog::RemoveTraceMask((wxString const &)*arg1);
9037
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 Py_INCREF(Py_None); resultobj = Py_None;
9042 {
9043 if (temp1)
9044 delete arg1;
9045 }
9046 return resultobj;
9047 fail:
9048 {
9049 if (temp1)
9050 delete arg1;
9051 }
9052 return NULL;
9053 }
9054
9055
9056 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9057 PyObject *resultobj;
9058 char *kwnames[] = {
9059 NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 wxLog::ClearTraceMasks();
9066
9067 wxPyEndAllowThreads(__tstate);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 Py_INCREF(Py_None); resultobj = Py_None;
9071 return resultobj;
9072 fail:
9073 return NULL;
9074 }
9075
9076
9077 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9078 PyObject *resultobj;
9079 wxArrayString *result;
9080 char *kwnames[] = {
9081 NULL
9082 };
9083
9084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9085 {
9086 PyThreadState* __tstate = wxPyBeginAllowThreads();
9087 {
9088 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9089 result = (wxArrayString *) &_result_ref;
9090 }
9091
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 {
9096 resultobj = wxArrayString2PyList_helper(*result);
9097 }
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9105 PyObject *resultobj;
9106 wxChar *arg1 = (wxChar *) 0 ;
9107 PyObject * obj0 = 0 ;
9108 char *kwnames[] = {
9109 (char *) "ts", NULL
9110 };
9111
9112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9114 if (SWIG_arg_fail(1)) SWIG_fail;
9115 {
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 wxLog::SetTimestamp((wxChar const *)arg1);
9118
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 Py_INCREF(Py_None); resultobj = Py_None;
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj;
9131 bool result;
9132 char *kwnames[] = {
9133 NULL
9134 };
9135
9136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9137 {
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (bool)wxLog::GetVerbose();
9140
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 {
9145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9146 }
9147 return resultobj;
9148 fail:
9149 return NULL;
9150 }
9151
9152
9153 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxTraceMask result;
9156 char *kwnames[] = {
9157 NULL
9158 };
9159
9160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 result = (wxTraceMask)wxLog::GetTraceMask();
9164
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 {
9169 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9170 }
9171 return resultobj;
9172 fail:
9173 return NULL;
9174 }
9175
9176
9177 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9178 PyObject *resultobj;
9179 wxChar *arg1 = (wxChar *) 0 ;
9180 bool result;
9181 PyObject * obj0 = 0 ;
9182 char *kwnames[] = {
9183 (char *) "mask", NULL
9184 };
9185
9186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9188 if (SWIG_arg_fail(1)) SWIG_fail;
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 {
9197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9198 }
9199 return resultobj;
9200 fail:
9201 return NULL;
9202 }
9203
9204
9205 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9206 PyObject *resultobj;
9207 wxLogLevel result;
9208 char *kwnames[] = {
9209 NULL
9210 };
9211
9212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (wxLogLevel)wxLog::GetLogLevel();
9216
9217 wxPyEndAllowThreads(__tstate);
9218 if (PyErr_Occurred()) SWIG_fail;
9219 }
9220 {
9221 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9222 }
9223 return resultobj;
9224 fail:
9225 return NULL;
9226 }
9227
9228
9229 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9230 PyObject *resultobj;
9231 wxChar *result;
9232 char *kwnames[] = {
9233 NULL
9234 };
9235
9236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (wxChar *)wxLog::GetTimestamp();
9240
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9245 return resultobj;
9246 fail:
9247 return NULL;
9248 }
9249
9250
9251 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9252 PyObject *resultobj;
9253 wxString result;
9254 char *kwnames[] = {
9255 NULL
9256 };
9257
9258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 result = Log_TimeStamp();
9262
9263 wxPyEndAllowThreads(__tstate);
9264 if (PyErr_Occurred()) SWIG_fail;
9265 }
9266 {
9267 #if wxUSE_UNICODE
9268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9269 #else
9270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9271 #endif
9272 }
9273 return resultobj;
9274 fail:
9275 return NULL;
9276 }
9277
9278
9279 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9280 PyObject *resultobj;
9281 wxLog *arg1 = (wxLog *) 0 ;
9282 PyObject * obj0 = 0 ;
9283 char *kwnames[] = {
9284 (char *) "self", NULL
9285 };
9286
9287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9289 if (SWIG_arg_fail(1)) SWIG_fail;
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 wxLog_Destroy(arg1);
9293
9294 wxPyEndAllowThreads(__tstate);
9295 if (PyErr_Occurred()) SWIG_fail;
9296 }
9297 Py_INCREF(Py_None); resultobj = Py_None;
9298 return resultobj;
9299 fail:
9300 return NULL;
9301 }
9302
9303
9304 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9305 PyObject *obj;
9306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9307 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9308 Py_INCREF(obj);
9309 return Py_BuildValue((char *)"");
9310 }
9311 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj;
9313 wxLogStderr *result;
9314 char *kwnames[] = {
9315 NULL
9316 };
9317
9318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 result = (wxLogStderr *)new wxLogStderr();
9322
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9334 PyObject *obj;
9335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9336 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9337 Py_INCREF(obj);
9338 return Py_BuildValue((char *)"");
9339 }
9340 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9343 wxLogTextCtrl *result;
9344 PyObject * obj0 = 0 ;
9345 char *kwnames[] = {
9346 (char *) "pTextCtrl", NULL
9347 };
9348
9349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9351 if (SWIG_arg_fail(1)) SWIG_fail;
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9355
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9367 PyObject *obj;
9368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9369 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9370 Py_INCREF(obj);
9371 return Py_BuildValue((char *)"");
9372 }
9373 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9374 PyObject *resultobj;
9375 wxLogGui *result;
9376 char *kwnames[] = {
9377 NULL
9378 };
9379
9380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (wxLogGui *)new wxLogGui();
9384
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9396 PyObject *obj;
9397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9398 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9399 Py_INCREF(obj);
9400 return Py_BuildValue((char *)"");
9401 }
9402 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj;
9404 wxFrame *arg1 = (wxFrame *) 0 ;
9405 wxString *arg2 = 0 ;
9406 bool arg3 = (bool) true ;
9407 bool arg4 = (bool) true ;
9408 wxLogWindow *result;
9409 bool temp2 = false ;
9410 PyObject * obj0 = 0 ;
9411 PyObject * obj1 = 0 ;
9412 PyObject * obj2 = 0 ;
9413 PyObject * obj3 = 0 ;
9414 char *kwnames[] = {
9415 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9416 };
9417
9418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9420 if (SWIG_arg_fail(1)) SWIG_fail;
9421 {
9422 arg2 = wxString_in_helper(obj1);
9423 if (arg2 == NULL) SWIG_fail;
9424 temp2 = true;
9425 }
9426 if (obj2) {
9427 {
9428 arg3 = (bool)(SWIG_As_bool(obj2));
9429 if (SWIG_arg_fail(3)) SWIG_fail;
9430 }
9431 }
9432 if (obj3) {
9433 {
9434 arg4 = (bool)(SWIG_As_bool(obj3));
9435 if (SWIG_arg_fail(4)) SWIG_fail;
9436 }
9437 }
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9441
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9446 {
9447 if (temp2)
9448 delete arg2;
9449 }
9450 return resultobj;
9451 fail:
9452 {
9453 if (temp2)
9454 delete arg2;
9455 }
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj;
9462 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9463 bool arg2 = (bool) true ;
9464 PyObject * obj0 = 0 ;
9465 PyObject * obj1 = 0 ;
9466 char *kwnames[] = {
9467 (char *) "self",(char *) "bShow", NULL
9468 };
9469
9470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9472 if (SWIG_arg_fail(1)) SWIG_fail;
9473 if (obj1) {
9474 {
9475 arg2 = (bool)(SWIG_As_bool(obj1));
9476 if (SWIG_arg_fail(2)) SWIG_fail;
9477 }
9478 }
9479 {
9480 PyThreadState* __tstate = wxPyBeginAllowThreads();
9481 (arg1)->Show(arg2);
9482
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 Py_INCREF(Py_None); resultobj = Py_None;
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj;
9495 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9496 wxFrame *result;
9497 PyObject * obj0 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "self", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(1)) SWIG_fail;
9505 {
9506 PyThreadState* __tstate = wxPyBeginAllowThreads();
9507 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9508
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 {
9513 resultobj = wxPyMake_wxObject(result, 0);
9514 }
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9522 PyObject *resultobj;
9523 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9524 wxLog *result;
9525 PyObject * obj0 = 0 ;
9526 char *kwnames[] = {
9527 (char *) "self", NULL
9528 };
9529
9530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9532 if (SWIG_arg_fail(1)) SWIG_fail;
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9536
9537 wxPyEndAllowThreads(__tstate);
9538 if (PyErr_Occurred()) SWIG_fail;
9539 }
9540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9541 return resultobj;
9542 fail:
9543 return NULL;
9544 }
9545
9546
9547 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9548 PyObject *resultobj;
9549 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9550 bool result;
9551 PyObject * obj0 = 0 ;
9552 char *kwnames[] = {
9553 (char *) "self", NULL
9554 };
9555
9556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9558 if (SWIG_arg_fail(1)) SWIG_fail;
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9562
9563 wxPyEndAllowThreads(__tstate);
9564 if (PyErr_Occurred()) SWIG_fail;
9565 }
9566 {
9567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9568 }
9569 return resultobj;
9570 fail:
9571 return NULL;
9572 }
9573
9574
9575 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj;
9577 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9578 bool arg2 ;
9579 PyObject * obj0 = 0 ;
9580 PyObject * obj1 = 0 ;
9581 char *kwnames[] = {
9582 (char *) "self",(char *) "bDoPass", NULL
9583 };
9584
9585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9587 if (SWIG_arg_fail(1)) SWIG_fail;
9588 {
9589 arg2 = (bool)(SWIG_As_bool(obj1));
9590 if (SWIG_arg_fail(2)) SWIG_fail;
9591 }
9592 {
9593 PyThreadState* __tstate = wxPyBeginAllowThreads();
9594 (arg1)->PassMessages(arg2);
9595
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 Py_INCREF(Py_None); resultobj = Py_None;
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9607 PyObject *obj;
9608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9609 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9610 Py_INCREF(obj);
9611 return Py_BuildValue((char *)"");
9612 }
9613 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9614 PyObject *resultobj;
9615 wxLog *arg1 = (wxLog *) 0 ;
9616 wxLogChain *result;
9617 PyObject * obj0 = 0 ;
9618 char *kwnames[] = {
9619 (char *) "logger", NULL
9620 };
9621
9622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9624 if (SWIG_arg_fail(1)) SWIG_fail;
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = (wxLogChain *)new wxLogChain(arg1);
9628
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9633 return resultobj;
9634 fail:
9635 return NULL;
9636 }
9637
9638
9639 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9640 PyObject *resultobj;
9641 wxLogChain *arg1 = (wxLogChain *) 0 ;
9642 wxLog *arg2 = (wxLog *) 0 ;
9643 PyObject * obj0 = 0 ;
9644 PyObject * obj1 = 0 ;
9645 char *kwnames[] = {
9646 (char *) "self",(char *) "logger", NULL
9647 };
9648
9649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9651 if (SWIG_arg_fail(1)) SWIG_fail;
9652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9653 if (SWIG_arg_fail(2)) SWIG_fail;
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->SetLog(arg2);
9657
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 Py_INCREF(Py_None); resultobj = Py_None;
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9669 PyObject *resultobj;
9670 wxLogChain *arg1 = (wxLogChain *) 0 ;
9671 bool arg2 ;
9672 PyObject * obj0 = 0 ;
9673 PyObject * obj1 = 0 ;
9674 char *kwnames[] = {
9675 (char *) "self",(char *) "bDoPass", NULL
9676 };
9677
9678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9680 if (SWIG_arg_fail(1)) SWIG_fail;
9681 {
9682 arg2 = (bool)(SWIG_As_bool(obj1));
9683 if (SWIG_arg_fail(2)) SWIG_fail;
9684 }
9685 {
9686 PyThreadState* __tstate = wxPyBeginAllowThreads();
9687 (arg1)->PassMessages(arg2);
9688
9689 wxPyEndAllowThreads(__tstate);
9690 if (PyErr_Occurred()) SWIG_fail;
9691 }
9692 Py_INCREF(Py_None); resultobj = Py_None;
9693 return resultobj;
9694 fail:
9695 return NULL;
9696 }
9697
9698
9699 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9700 PyObject *resultobj;
9701 wxLogChain *arg1 = (wxLogChain *) 0 ;
9702 bool result;
9703 PyObject * obj0 = 0 ;
9704 char *kwnames[] = {
9705 (char *) "self", NULL
9706 };
9707
9708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9710 if (SWIG_arg_fail(1)) SWIG_fail;
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (bool)(arg1)->IsPassingMessages();
9714
9715 wxPyEndAllowThreads(__tstate);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 {
9719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9720 }
9721 return resultobj;
9722 fail:
9723 return NULL;
9724 }
9725
9726
9727 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9728 PyObject *resultobj;
9729 wxLogChain *arg1 = (wxLogChain *) 0 ;
9730 wxLog *result;
9731 PyObject * obj0 = 0 ;
9732 char *kwnames[] = {
9733 (char *) "self", NULL
9734 };
9735
9736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9738 if (SWIG_arg_fail(1)) SWIG_fail;
9739 {
9740 PyThreadState* __tstate = wxPyBeginAllowThreads();
9741 result = (wxLog *)(arg1)->GetOldLog();
9742
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9747 return resultobj;
9748 fail:
9749 return NULL;
9750 }
9751
9752
9753 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9754 PyObject *obj;
9755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9756 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9757 Py_INCREF(obj);
9758 return Py_BuildValue((char *)"");
9759 }
9760 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9761 PyObject *resultobj;
9762 unsigned long result;
9763 char *kwnames[] = {
9764 NULL
9765 };
9766
9767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (unsigned long)wxSysErrorCode();
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9777 }
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj;
9786 unsigned long arg1 = (unsigned long) 0 ;
9787 wxString result;
9788 PyObject * obj0 = 0 ;
9789 char *kwnames[] = {
9790 (char *) "nErrCode", NULL
9791 };
9792
9793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9794 if (obj0) {
9795 {
9796 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9797 if (SWIG_arg_fail(1)) SWIG_fail;
9798 }
9799 }
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 result = wxSysErrorMsg(arg1);
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 {
9808 #if wxUSE_UNICODE
9809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9810 #else
9811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9812 #endif
9813 }
9814 return resultobj;
9815 fail:
9816 return NULL;
9817 }
9818
9819
9820 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9821 PyObject *resultobj;
9822 wxString *arg1 = 0 ;
9823 bool temp1 = false ;
9824 PyObject * obj0 = 0 ;
9825 char *kwnames[] = {
9826 (char *) "msg", NULL
9827 };
9828
9829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9830 {
9831 arg1 = wxString_in_helper(obj0);
9832 if (arg1 == NULL) SWIG_fail;
9833 temp1 = true;
9834 }
9835 {
9836 PyThreadState* __tstate = wxPyBeginAllowThreads();
9837 wxPyLogFatalError((wxString const &)*arg1);
9838
9839 wxPyEndAllowThreads(__tstate);
9840 if (PyErr_Occurred()) SWIG_fail;
9841 }
9842 Py_INCREF(Py_None); resultobj = Py_None;
9843 {
9844 if (temp1)
9845 delete arg1;
9846 }
9847 return resultobj;
9848 fail:
9849 {
9850 if (temp1)
9851 delete arg1;
9852 }
9853 return NULL;
9854 }
9855
9856
9857 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj;
9859 wxString *arg1 = 0 ;
9860 bool temp1 = false ;
9861 PyObject * obj0 = 0 ;
9862 char *kwnames[] = {
9863 (char *) "msg", NULL
9864 };
9865
9866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9867 {
9868 arg1 = wxString_in_helper(obj0);
9869 if (arg1 == NULL) SWIG_fail;
9870 temp1 = true;
9871 }
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 wxPyLogError((wxString const &)*arg1);
9875
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 Py_INCREF(Py_None); resultobj = Py_None;
9880 {
9881 if (temp1)
9882 delete arg1;
9883 }
9884 return resultobj;
9885 fail:
9886 {
9887 if (temp1)
9888 delete arg1;
9889 }
9890 return NULL;
9891 }
9892
9893
9894 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj;
9896 wxString *arg1 = 0 ;
9897 bool temp1 = false ;
9898 PyObject * obj0 = 0 ;
9899 char *kwnames[] = {
9900 (char *) "msg", NULL
9901 };
9902
9903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9904 {
9905 arg1 = wxString_in_helper(obj0);
9906 if (arg1 == NULL) SWIG_fail;
9907 temp1 = true;
9908 }
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 wxPyLogWarning((wxString const &)*arg1);
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 Py_INCREF(Py_None); resultobj = Py_None;
9917 {
9918 if (temp1)
9919 delete arg1;
9920 }
9921 return resultobj;
9922 fail:
9923 {
9924 if (temp1)
9925 delete arg1;
9926 }
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj;
9933 wxString *arg1 = 0 ;
9934 bool temp1 = false ;
9935 PyObject * obj0 = 0 ;
9936 char *kwnames[] = {
9937 (char *) "msg", NULL
9938 };
9939
9940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9941 {
9942 arg1 = wxString_in_helper(obj0);
9943 if (arg1 == NULL) SWIG_fail;
9944 temp1 = true;
9945 }
9946 {
9947 PyThreadState* __tstate = wxPyBeginAllowThreads();
9948 wxPyLogMessage((wxString const &)*arg1);
9949
9950 wxPyEndAllowThreads(__tstate);
9951 if (PyErr_Occurred()) SWIG_fail;
9952 }
9953 Py_INCREF(Py_None); resultobj = Py_None;
9954 {
9955 if (temp1)
9956 delete arg1;
9957 }
9958 return resultobj;
9959 fail:
9960 {
9961 if (temp1)
9962 delete arg1;
9963 }
9964 return NULL;
9965 }
9966
9967
9968 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9969 PyObject *resultobj;
9970 wxString *arg1 = 0 ;
9971 bool temp1 = false ;
9972 PyObject * obj0 = 0 ;
9973 char *kwnames[] = {
9974 (char *) "msg", NULL
9975 };
9976
9977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9978 {
9979 arg1 = wxString_in_helper(obj0);
9980 if (arg1 == NULL) SWIG_fail;
9981 temp1 = true;
9982 }
9983 {
9984 PyThreadState* __tstate = wxPyBeginAllowThreads();
9985 wxPyLogInfo((wxString const &)*arg1);
9986
9987 wxPyEndAllowThreads(__tstate);
9988 if (PyErr_Occurred()) SWIG_fail;
9989 }
9990 Py_INCREF(Py_None); resultobj = Py_None;
9991 {
9992 if (temp1)
9993 delete arg1;
9994 }
9995 return resultobj;
9996 fail:
9997 {
9998 if (temp1)
9999 delete arg1;
10000 }
10001 return NULL;
10002 }
10003
10004
10005 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj;
10007 wxString *arg1 = 0 ;
10008 bool temp1 = false ;
10009 PyObject * obj0 = 0 ;
10010 char *kwnames[] = {
10011 (char *) "msg", NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10015 {
10016 arg1 = wxString_in_helper(obj0);
10017 if (arg1 == NULL) SWIG_fail;
10018 temp1 = true;
10019 }
10020 {
10021 PyThreadState* __tstate = wxPyBeginAllowThreads();
10022 wxPyLogDebug((wxString const &)*arg1);
10023
10024 wxPyEndAllowThreads(__tstate);
10025 if (PyErr_Occurred()) SWIG_fail;
10026 }
10027 Py_INCREF(Py_None); resultobj = Py_None;
10028 {
10029 if (temp1)
10030 delete arg1;
10031 }
10032 return resultobj;
10033 fail:
10034 {
10035 if (temp1)
10036 delete arg1;
10037 }
10038 return NULL;
10039 }
10040
10041
10042 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10043 PyObject *resultobj;
10044 wxString *arg1 = 0 ;
10045 bool temp1 = false ;
10046 PyObject * obj0 = 0 ;
10047 char *kwnames[] = {
10048 (char *) "msg", NULL
10049 };
10050
10051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10052 {
10053 arg1 = wxString_in_helper(obj0);
10054 if (arg1 == NULL) SWIG_fail;
10055 temp1 = true;
10056 }
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 wxPyLogVerbose((wxString const &)*arg1);
10060
10061 wxPyEndAllowThreads(__tstate);
10062 if (PyErr_Occurred()) SWIG_fail;
10063 }
10064 Py_INCREF(Py_None); resultobj = Py_None;
10065 {
10066 if (temp1)
10067 delete arg1;
10068 }
10069 return resultobj;
10070 fail:
10071 {
10072 if (temp1)
10073 delete arg1;
10074 }
10075 return NULL;
10076 }
10077
10078
10079 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj;
10081 wxString *arg1 = 0 ;
10082 bool temp1 = false ;
10083 PyObject * obj0 = 0 ;
10084 char *kwnames[] = {
10085 (char *) "msg", NULL
10086 };
10087
10088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10089 {
10090 arg1 = wxString_in_helper(obj0);
10091 if (arg1 == NULL) SWIG_fail;
10092 temp1 = true;
10093 }
10094 {
10095 PyThreadState* __tstate = wxPyBeginAllowThreads();
10096 wxPyLogStatus((wxString const &)*arg1);
10097
10098 wxPyEndAllowThreads(__tstate);
10099 if (PyErr_Occurred()) SWIG_fail;
10100 }
10101 Py_INCREF(Py_None); resultobj = Py_None;
10102 {
10103 if (temp1)
10104 delete arg1;
10105 }
10106 return resultobj;
10107 fail:
10108 {
10109 if (temp1)
10110 delete arg1;
10111 }
10112 return NULL;
10113 }
10114
10115
10116 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10117 PyObject *resultobj;
10118 wxFrame *arg1 = (wxFrame *) 0 ;
10119 wxString *arg2 = 0 ;
10120 bool temp2 = false ;
10121 PyObject * obj0 = 0 ;
10122 PyObject * obj1 = 0 ;
10123 char *kwnames[] = {
10124 (char *) "pFrame",(char *) "msg", NULL
10125 };
10126
10127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10129 if (SWIG_arg_fail(1)) SWIG_fail;
10130 {
10131 arg2 = wxString_in_helper(obj1);
10132 if (arg2 == NULL) SWIG_fail;
10133 temp2 = true;
10134 }
10135 {
10136 PyThreadState* __tstate = wxPyBeginAllowThreads();
10137 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10138
10139 wxPyEndAllowThreads(__tstate);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 Py_INCREF(Py_None); resultobj = Py_None;
10143 {
10144 if (temp2)
10145 delete arg2;
10146 }
10147 return resultobj;
10148 fail:
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return NULL;
10154 }
10155
10156
10157 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10158 PyObject *resultobj;
10159 wxString *arg1 = 0 ;
10160 bool temp1 = false ;
10161 PyObject * obj0 = 0 ;
10162 char *kwnames[] = {
10163 (char *) "msg", NULL
10164 };
10165
10166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10167 {
10168 arg1 = wxString_in_helper(obj0);
10169 if (arg1 == NULL) SWIG_fail;
10170 temp1 = true;
10171 }
10172 {
10173 PyThreadState* __tstate = wxPyBeginAllowThreads();
10174 wxPyLogSysError((wxString const &)*arg1);
10175
10176 wxPyEndAllowThreads(__tstate);
10177 if (PyErr_Occurred()) SWIG_fail;
10178 }
10179 Py_INCREF(Py_None); resultobj = Py_None;
10180 {
10181 if (temp1)
10182 delete arg1;
10183 }
10184 return resultobj;
10185 fail:
10186 {
10187 if (temp1)
10188 delete arg1;
10189 }
10190 return NULL;
10191 }
10192
10193
10194 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj;
10196 unsigned long arg1 ;
10197 wxString *arg2 = 0 ;
10198 bool temp2 = false ;
10199 PyObject * obj0 = 0 ;
10200 PyObject * obj1 = 0 ;
10201 char *kwnames[] = {
10202 (char *) "level",(char *) "msg", NULL
10203 };
10204
10205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10206 {
10207 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10208 if (SWIG_arg_fail(1)) SWIG_fail;
10209 }
10210 {
10211 arg2 = wxString_in_helper(obj1);
10212 if (arg2 == NULL) SWIG_fail;
10213 temp2 = true;
10214 }
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10218
10219 wxPyEndAllowThreads(__tstate);
10220 if (PyErr_Occurred()) SWIG_fail;
10221 }
10222 Py_INCREF(Py_None); resultobj = Py_None;
10223 {
10224 if (temp2)
10225 delete arg2;
10226 }
10227 return resultobj;
10228 fail:
10229 {
10230 if (temp2)
10231 delete arg2;
10232 }
10233 return NULL;
10234 }
10235
10236
10237 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10238 PyObject *resultobj;
10239 unsigned long arg1 ;
10240 wxString *arg2 = 0 ;
10241 bool temp2 = false ;
10242 PyObject * obj0 = 0 ;
10243 PyObject * obj1 = 0 ;
10244
10245 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10246 {
10247 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10248 if (SWIG_arg_fail(1)) SWIG_fail;
10249 }
10250 {
10251 arg2 = wxString_in_helper(obj1);
10252 if (arg2 == NULL) SWIG_fail;
10253 temp2 = true;
10254 }
10255 {
10256 PyThreadState* __tstate = wxPyBeginAllowThreads();
10257 wxPyLogTrace(arg1,(wxString const &)*arg2);
10258
10259 wxPyEndAllowThreads(__tstate);
10260 if (PyErr_Occurred()) SWIG_fail;
10261 }
10262 Py_INCREF(Py_None); resultobj = Py_None;
10263 {
10264 if (temp2)
10265 delete arg2;
10266 }
10267 return resultobj;
10268 fail:
10269 {
10270 if (temp2)
10271 delete arg2;
10272 }
10273 return NULL;
10274 }
10275
10276
10277 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10278 PyObject *resultobj;
10279 wxString *arg1 = 0 ;
10280 wxString *arg2 = 0 ;
10281 bool temp1 = false ;
10282 bool temp2 = false ;
10283 PyObject * obj0 = 0 ;
10284 PyObject * obj1 = 0 ;
10285
10286 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10287 {
10288 arg1 = wxString_in_helper(obj0);
10289 if (arg1 == NULL) SWIG_fail;
10290 temp1 = true;
10291 }
10292 {
10293 arg2 = wxString_in_helper(obj1);
10294 if (arg2 == NULL) SWIG_fail;
10295 temp2 = true;
10296 }
10297 {
10298 PyThreadState* __tstate = wxPyBeginAllowThreads();
10299 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10300
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 Py_INCREF(Py_None); resultobj = Py_None;
10305 {
10306 if (temp1)
10307 delete arg1;
10308 }
10309 {
10310 if (temp2)
10311 delete arg2;
10312 }
10313 return resultobj;
10314 fail:
10315 {
10316 if (temp1)
10317 delete arg1;
10318 }
10319 {
10320 if (temp2)
10321 delete arg2;
10322 }
10323 return NULL;
10324 }
10325
10326
10327 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10328 int argc;
10329 PyObject *argv[3];
10330 int ii;
10331
10332 argc = PyObject_Length(args);
10333 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10334 argv[ii] = PyTuple_GetItem(args,ii);
10335 }
10336 if (argc == 2) {
10337 int _v;
10338 {
10339 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10340 }
10341 if (_v) {
10342 {
10343 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10344 }
10345 if (_v) {
10346 return _wrap_LogTrace__SWIG_1(self,args);
10347 }
10348 }
10349 }
10350 if (argc == 2) {
10351 int _v;
10352 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10353 if (_v) {
10354 {
10355 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10356 }
10357 if (_v) {
10358 return _wrap_LogTrace__SWIG_0(self,args);
10359 }
10360 }
10361 }
10362
10363 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10364 return NULL;
10365 }
10366
10367
10368 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj;
10370 wxString *arg1 = 0 ;
10371 wxString *arg2 = 0 ;
10372 bool temp1 = false ;
10373 bool temp2 = false ;
10374 PyObject * obj0 = 0 ;
10375 PyObject * obj1 = 0 ;
10376 char *kwnames[] = {
10377 (char *) "title",(char *) "text", NULL
10378 };
10379
10380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10381 {
10382 arg1 = wxString_in_helper(obj0);
10383 if (arg1 == NULL) SWIG_fail;
10384 temp1 = true;
10385 }
10386 {
10387 arg2 = wxString_in_helper(obj1);
10388 if (arg2 == NULL) SWIG_fail;
10389 temp2 = true;
10390 }
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10394
10395 wxPyEndAllowThreads(__tstate);
10396 if (PyErr_Occurred()) SWIG_fail;
10397 }
10398 Py_INCREF(Py_None); resultobj = Py_None;
10399 {
10400 if (temp1)
10401 delete arg1;
10402 }
10403 {
10404 if (temp2)
10405 delete arg2;
10406 }
10407 return resultobj;
10408 fail:
10409 {
10410 if (temp1)
10411 delete arg1;
10412 }
10413 {
10414 if (temp2)
10415 delete arg2;
10416 }
10417 return NULL;
10418 }
10419
10420
10421 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10422 PyObject *resultobj;
10423 wxLogNull *result;
10424 char *kwnames[] = {
10425 NULL
10426 };
10427
10428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10429 {
10430 PyThreadState* __tstate = wxPyBeginAllowThreads();
10431 result = (wxLogNull *)new wxLogNull();
10432
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10437 return resultobj;
10438 fail:
10439 return NULL;
10440 }
10441
10442
10443 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10444 PyObject *resultobj;
10445 wxLogNull *arg1 = (wxLogNull *) 0 ;
10446 PyObject * obj0 = 0 ;
10447 char *kwnames[] = {
10448 (char *) "self", NULL
10449 };
10450
10451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10453 if (SWIG_arg_fail(1)) SWIG_fail;
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 delete arg1;
10457
10458 wxPyEndAllowThreads(__tstate);
10459 if (PyErr_Occurred()) SWIG_fail;
10460 }
10461 Py_INCREF(Py_None); resultobj = Py_None;
10462 return resultobj;
10463 fail:
10464 return NULL;
10465 }
10466
10467
10468 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10469 PyObject *obj;
10470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10471 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10472 Py_INCREF(obj);
10473 return Py_BuildValue((char *)"");
10474 }
10475 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10476 PyObject *resultobj;
10477 wxPyLog *result;
10478 char *kwnames[] = {
10479 NULL
10480 };
10481
10482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10483 {
10484 PyThreadState* __tstate = wxPyBeginAllowThreads();
10485 result = (wxPyLog *)new wxPyLog();
10486
10487 wxPyEndAllowThreads(__tstate);
10488 if (PyErr_Occurred()) SWIG_fail;
10489 }
10490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10491 return resultobj;
10492 fail:
10493 return NULL;
10494 }
10495
10496
10497 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10498 PyObject *resultobj;
10499 wxPyLog *arg1 = (wxPyLog *) 0 ;
10500 PyObject *arg2 = (PyObject *) 0 ;
10501 PyObject *arg3 = (PyObject *) 0 ;
10502 PyObject * obj0 = 0 ;
10503 PyObject * obj1 = 0 ;
10504 PyObject * obj2 = 0 ;
10505 char *kwnames[] = {
10506 (char *) "self",(char *) "self",(char *) "_class", NULL
10507 };
10508
10509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10511 if (SWIG_arg_fail(1)) SWIG_fail;
10512 arg2 = obj1;
10513 arg3 = obj2;
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 (arg1)->_setCallbackInfo(arg2,arg3);
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 Py_INCREF(Py_None); resultobj = Py_None;
10522 return resultobj;
10523 fail:
10524 return NULL;
10525 }
10526
10527
10528 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10529 PyObject *obj;
10530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10531 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10532 Py_INCREF(obj);
10533 return Py_BuildValue((char *)"");
10534 }
10535 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10536 PyObject *resultobj;
10537 int arg1 ;
10538 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10539 int arg3 = (int) wxKILL_NOCHILDREN ;
10540 wxKillError result;
10541 PyObject * obj0 = 0 ;
10542 PyObject * obj1 = 0 ;
10543 PyObject * obj2 = 0 ;
10544 char *kwnames[] = {
10545 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10546 };
10547
10548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10549 {
10550 arg1 = (int)(SWIG_As_int(obj0));
10551 if (SWIG_arg_fail(1)) SWIG_fail;
10552 }
10553 if (obj1) {
10554 {
10555 arg2 = (wxSignal)(SWIG_As_int(obj1));
10556 if (SWIG_arg_fail(2)) SWIG_fail;
10557 }
10558 }
10559 if (obj2) {
10560 {
10561 arg3 = (int)(SWIG_As_int(obj2));
10562 if (SWIG_arg_fail(3)) SWIG_fail;
10563 }
10564 }
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10568
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 resultobj = SWIG_From_int((result));
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10580 PyObject *resultobj;
10581 int arg1 ;
10582 bool result;
10583 PyObject * obj0 = 0 ;
10584 char *kwnames[] = {
10585 (char *) "pid", NULL
10586 };
10587
10588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10589 {
10590 arg1 = (int)(SWIG_As_int(obj0));
10591 if (SWIG_arg_fail(1)) SWIG_fail;
10592 }
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (bool)wxPyProcess::Exists(arg1);
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 {
10601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10602 }
10603 return resultobj;
10604 fail:
10605 return NULL;
10606 }
10607
10608
10609 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10610 PyObject *resultobj;
10611 wxString *arg1 = 0 ;
10612 int arg2 = (int) wxEXEC_ASYNC ;
10613 wxPyProcess *result;
10614 bool temp1 = false ;
10615 PyObject * obj0 = 0 ;
10616 PyObject * obj1 = 0 ;
10617 char *kwnames[] = {
10618 (char *) "cmd",(char *) "flags", NULL
10619 };
10620
10621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10622 {
10623 arg1 = wxString_in_helper(obj0);
10624 if (arg1 == NULL) SWIG_fail;
10625 temp1 = true;
10626 }
10627 if (obj1) {
10628 {
10629 arg2 = (int)(SWIG_As_int(obj1));
10630 if (SWIG_arg_fail(2)) SWIG_fail;
10631 }
10632 }
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10636
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10641 {
10642 if (temp1)
10643 delete arg1;
10644 }
10645 return resultobj;
10646 fail:
10647 {
10648 if (temp1)
10649 delete arg1;
10650 }
10651 return NULL;
10652 }
10653
10654
10655 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj;
10657 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10658 int arg2 = (int) -1 ;
10659 wxPyProcess *result;
10660 PyObject * obj0 = 0 ;
10661 PyObject * obj1 = 0 ;
10662 char *kwnames[] = {
10663 (char *) "parent",(char *) "id", NULL
10664 };
10665
10666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10667 if (obj0) {
10668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10669 if (SWIG_arg_fail(1)) SWIG_fail;
10670 }
10671 if (obj1) {
10672 {
10673 arg2 = (int)(SWIG_As_int(obj1));
10674 if (SWIG_arg_fail(2)) SWIG_fail;
10675 }
10676 }
10677 {
10678 PyThreadState* __tstate = wxPyBeginAllowThreads();
10679 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10680
10681 wxPyEndAllowThreads(__tstate);
10682 if (PyErr_Occurred()) SWIG_fail;
10683 }
10684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10685 return resultobj;
10686 fail:
10687 return NULL;
10688 }
10689
10690
10691 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj;
10693 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10694 PyObject *arg2 = (PyObject *) 0 ;
10695 PyObject *arg3 = (PyObject *) 0 ;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 PyObject * obj2 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "self",(char *) "self",(char *) "_class", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10705 if (SWIG_arg_fail(1)) SWIG_fail;
10706 arg2 = obj1;
10707 arg3 = obj2;
10708 {
10709 PyThreadState* __tstate = wxPyBeginAllowThreads();
10710 (arg1)->_setCallbackInfo(arg2,arg3);
10711
10712 wxPyEndAllowThreads(__tstate);
10713 if (PyErr_Occurred()) SWIG_fail;
10714 }
10715 Py_INCREF(Py_None); resultobj = Py_None;
10716 return resultobj;
10717 fail:
10718 return NULL;
10719 }
10720
10721
10722 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10723 PyObject *resultobj;
10724 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10725 int arg2 ;
10726 int arg3 ;
10727 PyObject * obj0 = 0 ;
10728 PyObject * obj1 = 0 ;
10729 PyObject * obj2 = 0 ;
10730 char *kwnames[] = {
10731 (char *) "self",(char *) "pid",(char *) "status", NULL
10732 };
10733
10734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10736 if (SWIG_arg_fail(1)) SWIG_fail;
10737 {
10738 arg2 = (int)(SWIG_As_int(obj1));
10739 if (SWIG_arg_fail(2)) SWIG_fail;
10740 }
10741 {
10742 arg3 = (int)(SWIG_As_int(obj2));
10743 if (SWIG_arg_fail(3)) SWIG_fail;
10744 }
10745 {
10746 PyThreadState* __tstate = wxPyBeginAllowThreads();
10747 (arg1)->base_OnTerminate(arg2,arg3);
10748
10749 wxPyEndAllowThreads(__tstate);
10750 if (PyErr_Occurred()) SWIG_fail;
10751 }
10752 Py_INCREF(Py_None); resultobj = Py_None;
10753 return resultobj;
10754 fail:
10755 return NULL;
10756 }
10757
10758
10759 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10760 PyObject *resultobj;
10761 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10762 PyObject * obj0 = 0 ;
10763 char *kwnames[] = {
10764 (char *) "self", NULL
10765 };
10766
10767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10769 if (SWIG_arg_fail(1)) SWIG_fail;
10770 {
10771 PyThreadState* __tstate = wxPyBeginAllowThreads();
10772 (arg1)->Redirect();
10773
10774 wxPyEndAllowThreads(__tstate);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 Py_INCREF(Py_None); resultobj = Py_None;
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj;
10786 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10787 bool result;
10788 PyObject * obj0 = 0 ;
10789 char *kwnames[] = {
10790 (char *) "self", NULL
10791 };
10792
10793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10795 if (SWIG_arg_fail(1)) SWIG_fail;
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 result = (bool)(arg1)->IsRedirected();
10799
10800 wxPyEndAllowThreads(__tstate);
10801 if (PyErr_Occurred()) SWIG_fail;
10802 }
10803 {
10804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10805 }
10806 return resultobj;
10807 fail:
10808 return NULL;
10809 }
10810
10811
10812 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10813 PyObject *resultobj;
10814 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10815 PyObject * obj0 = 0 ;
10816 char *kwnames[] = {
10817 (char *) "self", NULL
10818 };
10819
10820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10822 if (SWIG_arg_fail(1)) SWIG_fail;
10823 {
10824 PyThreadState* __tstate = wxPyBeginAllowThreads();
10825 (arg1)->Detach();
10826
10827 wxPyEndAllowThreads(__tstate);
10828 if (PyErr_Occurred()) SWIG_fail;
10829 }
10830 Py_INCREF(Py_None); resultobj = Py_None;
10831 return resultobj;
10832 fail:
10833 return NULL;
10834 }
10835
10836
10837 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10838 PyObject *resultobj;
10839 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10840 wxInputStream *result;
10841 PyObject * obj0 = 0 ;
10842 char *kwnames[] = {
10843 (char *) "self", NULL
10844 };
10845
10846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10848 if (SWIG_arg_fail(1)) SWIG_fail;
10849 {
10850 PyThreadState* __tstate = wxPyBeginAllowThreads();
10851 result = (wxInputStream *)(arg1)->GetInputStream();
10852
10853 wxPyEndAllowThreads(__tstate);
10854 if (PyErr_Occurred()) SWIG_fail;
10855 }
10856 {
10857 wxPyInputStream * _ptr = NULL;
10858
10859 if (result) {
10860 _ptr = new wxPyInputStream(result);
10861 }
10862 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10863 }
10864 return resultobj;
10865 fail:
10866 return NULL;
10867 }
10868
10869
10870 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj;
10872 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10873 wxInputStream *result;
10874 PyObject * obj0 = 0 ;
10875 char *kwnames[] = {
10876 (char *) "self", NULL
10877 };
10878
10879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10881 if (SWIG_arg_fail(1)) SWIG_fail;
10882 {
10883 PyThreadState* __tstate = wxPyBeginAllowThreads();
10884 result = (wxInputStream *)(arg1)->GetErrorStream();
10885
10886 wxPyEndAllowThreads(__tstate);
10887 if (PyErr_Occurred()) SWIG_fail;
10888 }
10889 {
10890 wxPyInputStream * _ptr = NULL;
10891
10892 if (result) {
10893 _ptr = new wxPyInputStream(result);
10894 }
10895 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10896 }
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10906 wxOutputStream *result;
10907 PyObject * obj0 = 0 ;
10908 char *kwnames[] = {
10909 (char *) "self", NULL
10910 };
10911
10912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10914 if (SWIG_arg_fail(1)) SWIG_fail;
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 result = (wxOutputStream *)(arg1)->GetOutputStream();
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj;
10931 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10932 PyObject * obj0 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "self", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 {
10941 PyThreadState* __tstate = wxPyBeginAllowThreads();
10942 (arg1)->CloseOutput();
10943
10944 wxPyEndAllowThreads(__tstate);
10945 if (PyErr_Occurred()) SWIG_fail;
10946 }
10947 Py_INCREF(Py_None); resultobj = Py_None;
10948 return resultobj;
10949 fail:
10950 return NULL;
10951 }
10952
10953
10954 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10955 PyObject *resultobj;
10956 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10957 bool result;
10958 PyObject * obj0 = 0 ;
10959 char *kwnames[] = {
10960 (char *) "self", NULL
10961 };
10962
10963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10965 if (SWIG_arg_fail(1)) SWIG_fail;
10966 {
10967 PyThreadState* __tstate = wxPyBeginAllowThreads();
10968 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10969
10970 wxPyEndAllowThreads(__tstate);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 {
10974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10975 }
10976 return resultobj;
10977 fail:
10978 return NULL;
10979 }
10980
10981
10982 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10983 PyObject *resultobj;
10984 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10985 bool result;
10986 PyObject * obj0 = 0 ;
10987 char *kwnames[] = {
10988 (char *) "self", NULL
10989 };
10990
10991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10993 if (SWIG_arg_fail(1)) SWIG_fail;
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
10997
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 {
11002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11003 }
11004 return resultobj;
11005 fail:
11006 return NULL;
11007 }
11008
11009
11010 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj;
11012 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11013 bool result;
11014 PyObject * obj0 = 0 ;
11015 char *kwnames[] = {
11016 (char *) "self", NULL
11017 };
11018
11019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11021 if (SWIG_arg_fail(1)) SWIG_fail;
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11025
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 {
11030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11031 }
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11039 PyObject *obj;
11040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11041 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11042 Py_INCREF(obj);
11043 return Py_BuildValue((char *)"");
11044 }
11045 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11046 PyObject *resultobj;
11047 int arg1 = (int) 0 ;
11048 int arg2 = (int) 0 ;
11049 int arg3 = (int) 0 ;
11050 wxProcessEvent *result;
11051 PyObject * obj0 = 0 ;
11052 PyObject * obj1 = 0 ;
11053 PyObject * obj2 = 0 ;
11054 char *kwnames[] = {
11055 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11056 };
11057
11058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11059 if (obj0) {
11060 {
11061 arg1 = (int)(SWIG_As_int(obj0));
11062 if (SWIG_arg_fail(1)) SWIG_fail;
11063 }
11064 }
11065 if (obj1) {
11066 {
11067 arg2 = (int)(SWIG_As_int(obj1));
11068 if (SWIG_arg_fail(2)) SWIG_fail;
11069 }
11070 }
11071 if (obj2) {
11072 {
11073 arg3 = (int)(SWIG_As_int(obj2));
11074 if (SWIG_arg_fail(3)) SWIG_fail;
11075 }
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11080
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj;
11093 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11094 int result;
11095 PyObject * obj0 = 0 ;
11096 char *kwnames[] = {
11097 (char *) "self", NULL
11098 };
11099
11100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11102 if (SWIG_arg_fail(1)) SWIG_fail;
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (int)(arg1)->GetPid();
11106
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 {
11111 resultobj = SWIG_From_int((int)(result));
11112 }
11113 return resultobj;
11114 fail:
11115 return NULL;
11116 }
11117
11118
11119 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11120 PyObject *resultobj;
11121 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11122 int result;
11123 PyObject * obj0 = 0 ;
11124 char *kwnames[] = {
11125 (char *) "self", NULL
11126 };
11127
11128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11130 if (SWIG_arg_fail(1)) SWIG_fail;
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 result = (int)(arg1)->GetExitCode();
11134
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 {
11139 resultobj = SWIG_From_int((int)(result));
11140 }
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11150 int arg2 ;
11151 PyObject * obj0 = 0 ;
11152 PyObject * obj1 = 0 ;
11153 char *kwnames[] = {
11154 (char *) "self",(char *) "m_pid", NULL
11155 };
11156
11157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11159 if (SWIG_arg_fail(1)) SWIG_fail;
11160 {
11161 arg2 = (int)(SWIG_As_int(obj1));
11162 if (SWIG_arg_fail(2)) SWIG_fail;
11163 }
11164 if (arg1) (arg1)->m_pid = arg2;
11165
11166 Py_INCREF(Py_None); resultobj = Py_None;
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11174 PyObject *resultobj;
11175 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11176 int result;
11177 PyObject * obj0 = 0 ;
11178 char *kwnames[] = {
11179 (char *) "self", NULL
11180 };
11181
11182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11184 if (SWIG_arg_fail(1)) SWIG_fail;
11185 result = (int) ((arg1)->m_pid);
11186
11187 {
11188 resultobj = SWIG_From_int((int)(result));
11189 }
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj;
11198 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11199 int arg2 ;
11200 PyObject * obj0 = 0 ;
11201 PyObject * obj1 = 0 ;
11202 char *kwnames[] = {
11203 (char *) "self",(char *) "m_exitcode", NULL
11204 };
11205
11206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11208 if (SWIG_arg_fail(1)) SWIG_fail;
11209 {
11210 arg2 = (int)(SWIG_As_int(obj1));
11211 if (SWIG_arg_fail(2)) SWIG_fail;
11212 }
11213 if (arg1) (arg1)->m_exitcode = arg2;
11214
11215 Py_INCREF(Py_None); resultobj = Py_None;
11216 return resultobj;
11217 fail:
11218 return NULL;
11219 }
11220
11221
11222 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11223 PyObject *resultobj;
11224 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11225 int result;
11226 PyObject * obj0 = 0 ;
11227 char *kwnames[] = {
11228 (char *) "self", NULL
11229 };
11230
11231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11233 if (SWIG_arg_fail(1)) SWIG_fail;
11234 result = (int) ((arg1)->m_exitcode);
11235
11236 {
11237 resultobj = SWIG_From_int((int)(result));
11238 }
11239 return resultobj;
11240 fail:
11241 return NULL;
11242 }
11243
11244
11245 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11246 PyObject *obj;
11247 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11248 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11249 Py_INCREF(obj);
11250 return Py_BuildValue((char *)"");
11251 }
11252 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj;
11254 wxString *arg1 = 0 ;
11255 int arg2 = (int) wxEXEC_ASYNC ;
11256 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11257 long result;
11258 bool temp1 = false ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 char *kwnames[] = {
11263 (char *) "command",(char *) "flags",(char *) "process", NULL
11264 };
11265
11266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11267 {
11268 arg1 = wxString_in_helper(obj0);
11269 if (arg1 == NULL) SWIG_fail;
11270 temp1 = true;
11271 }
11272 if (obj1) {
11273 {
11274 arg2 = (int)(SWIG_As_int(obj1));
11275 if (SWIG_arg_fail(2)) SWIG_fail;
11276 }
11277 }
11278 if (obj2) {
11279 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11280 if (SWIG_arg_fail(3)) SWIG_fail;
11281 }
11282 {
11283 if (!wxPyCheckForApp()) SWIG_fail;
11284 PyThreadState* __tstate = wxPyBeginAllowThreads();
11285 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11286
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 {
11291 resultobj = SWIG_From_long((long)(result));
11292 }
11293 {
11294 if (temp1)
11295 delete arg1;
11296 }
11297 return resultobj;
11298 fail:
11299 {
11300 if (temp1)
11301 delete arg1;
11302 }
11303 return NULL;
11304 }
11305
11306
11307 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj;
11309 long arg1 ;
11310 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11311 wxKillError *arg3 = (wxKillError *) 0 ;
11312 int arg4 = (int) wxKILL_NOCHILDREN ;
11313 int result;
11314 wxKillError temp3 ;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 PyObject * obj2 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11320 };
11321
11322 {
11323 arg3 = &temp3;
11324 }
11325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11326 {
11327 arg1 = (long)(SWIG_As_long(obj0));
11328 if (SWIG_arg_fail(1)) SWIG_fail;
11329 }
11330 if (obj1) {
11331 {
11332 arg2 = (wxSignal)(SWIG_As_int(obj1));
11333 if (SWIG_arg_fail(2)) SWIG_fail;
11334 }
11335 }
11336 if (obj2) {
11337 {
11338 arg4 = (int)(SWIG_As_int(obj2));
11339 if (SWIG_arg_fail(4)) SWIG_fail;
11340 }
11341 }
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11345
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 resultobj = SWIG_From_int((int)(result));
11351 }
11352 {
11353 PyObject* o;
11354 o = PyInt_FromLong((long) (*arg3));
11355 resultobj = t_output_helper(resultobj, o);
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 int arg1 = (int) wxJOYSTICK1 ;
11366 wxJoystick *result;
11367 PyObject * obj0 = 0 ;
11368 char *kwnames[] = {
11369 (char *) "joystick", NULL
11370 };
11371
11372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11373 if (obj0) {
11374 {
11375 arg1 = (int)(SWIG_As_int(obj0));
11376 if (SWIG_arg_fail(1)) SWIG_fail;
11377 }
11378 }
11379 {
11380 if (!wxPyCheckForApp()) SWIG_fail;
11381 PyThreadState* __tstate = wxPyBeginAllowThreads();
11382 result = (wxJoystick *)new wxJoystick(arg1);
11383
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11388 return resultobj;
11389 fail:
11390 return NULL;
11391 }
11392
11393
11394 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11395 PyObject *resultobj;
11396 wxJoystick *arg1 = (wxJoystick *) 0 ;
11397 PyObject * obj0 = 0 ;
11398 char *kwnames[] = {
11399 (char *) "self", NULL
11400 };
11401
11402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11404 if (SWIG_arg_fail(1)) SWIG_fail;
11405 {
11406 PyThreadState* __tstate = wxPyBeginAllowThreads();
11407 delete arg1;
11408
11409 wxPyEndAllowThreads(__tstate);
11410 if (PyErr_Occurred()) SWIG_fail;
11411 }
11412 Py_INCREF(Py_None); resultobj = Py_None;
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11420 PyObject *resultobj;
11421 wxJoystick *arg1 = (wxJoystick *) 0 ;
11422 wxPoint result;
11423 PyObject * obj0 = 0 ;
11424 char *kwnames[] = {
11425 (char *) "self", NULL
11426 };
11427
11428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11430 if (SWIG_arg_fail(1)) SWIG_fail;
11431 {
11432 PyThreadState* __tstate = wxPyBeginAllowThreads();
11433 result = (arg1)->GetPosition();
11434
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 {
11439 wxPoint * resultptr;
11440 resultptr = new wxPoint((wxPoint &)(result));
11441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11442 }
11443 return resultobj;
11444 fail:
11445 return NULL;
11446 }
11447
11448
11449 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj;
11451 wxJoystick *arg1 = (wxJoystick *) 0 ;
11452 int result;
11453 PyObject * obj0 = 0 ;
11454 char *kwnames[] = {
11455 (char *) "self", NULL
11456 };
11457
11458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11460 if (SWIG_arg_fail(1)) SWIG_fail;
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 result = (int)(arg1)->GetZPosition();
11464
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 {
11469 resultobj = SWIG_From_int((int)(result));
11470 }
11471 return resultobj;
11472 fail:
11473 return NULL;
11474 }
11475
11476
11477 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11478 PyObject *resultobj;
11479 wxJoystick *arg1 = (wxJoystick *) 0 ;
11480 int result;
11481 PyObject * obj0 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "self", NULL
11484 };
11485
11486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11488 if (SWIG_arg_fail(1)) SWIG_fail;
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (int)(arg1)->GetButtonState();
11492
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 {
11497 resultobj = SWIG_From_int((int)(result));
11498 }
11499 return resultobj;
11500 fail:
11501 return NULL;
11502 }
11503
11504
11505 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj;
11507 wxJoystick *arg1 = (wxJoystick *) 0 ;
11508 int result;
11509 PyObject * obj0 = 0 ;
11510 char *kwnames[] = {
11511 (char *) "self", NULL
11512 };
11513
11514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11516 if (SWIG_arg_fail(1)) SWIG_fail;
11517 {
11518 PyThreadState* __tstate = wxPyBeginAllowThreads();
11519 result = (int)(arg1)->GetPOVPosition();
11520
11521 wxPyEndAllowThreads(__tstate);
11522 if (PyErr_Occurred()) SWIG_fail;
11523 }
11524 {
11525 resultobj = SWIG_From_int((int)(result));
11526 }
11527 return resultobj;
11528 fail:
11529 return NULL;
11530 }
11531
11532
11533 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11534 PyObject *resultobj;
11535 wxJoystick *arg1 = (wxJoystick *) 0 ;
11536 int result;
11537 PyObject * obj0 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "self", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11544 if (SWIG_arg_fail(1)) SWIG_fail;
11545 {
11546 PyThreadState* __tstate = wxPyBeginAllowThreads();
11547 result = (int)(arg1)->GetPOVCTSPosition();
11548
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 {
11553 resultobj = SWIG_From_int((int)(result));
11554 }
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11562 PyObject *resultobj;
11563 wxJoystick *arg1 = (wxJoystick *) 0 ;
11564 int result;
11565 PyObject * obj0 = 0 ;
11566 char *kwnames[] = {
11567 (char *) "self", NULL
11568 };
11569
11570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11572 if (SWIG_arg_fail(1)) SWIG_fail;
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (int)(arg1)->GetRudderPosition();
11576
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 {
11581 resultobj = SWIG_From_int((int)(result));
11582 }
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj;
11591 wxJoystick *arg1 = (wxJoystick *) 0 ;
11592 int result;
11593 PyObject * obj0 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "self", NULL
11596 };
11597
11598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11600 if (SWIG_arg_fail(1)) SWIG_fail;
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 result = (int)(arg1)->GetUPosition();
11604
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 {
11609 resultobj = SWIG_From_int((int)(result));
11610 }
11611 return resultobj;
11612 fail:
11613 return NULL;
11614 }
11615
11616
11617 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11618 PyObject *resultobj;
11619 wxJoystick *arg1 = (wxJoystick *) 0 ;
11620 int result;
11621 PyObject * obj0 = 0 ;
11622 char *kwnames[] = {
11623 (char *) "self", NULL
11624 };
11625
11626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11628 if (SWIG_arg_fail(1)) SWIG_fail;
11629 {
11630 PyThreadState* __tstate = wxPyBeginAllowThreads();
11631 result = (int)(arg1)->GetVPosition();
11632
11633 wxPyEndAllowThreads(__tstate);
11634 if (PyErr_Occurred()) SWIG_fail;
11635 }
11636 {
11637 resultobj = SWIG_From_int((int)(result));
11638 }
11639 return resultobj;
11640 fail:
11641 return NULL;
11642 }
11643
11644
11645 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11646 PyObject *resultobj;
11647 wxJoystick *arg1 = (wxJoystick *) 0 ;
11648 int result;
11649 PyObject * obj0 = 0 ;
11650 char *kwnames[] = {
11651 (char *) "self", NULL
11652 };
11653
11654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11656 if (SWIG_arg_fail(1)) SWIG_fail;
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (int)(arg1)->GetMovementThreshold();
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 {
11665 resultobj = SWIG_From_int((int)(result));
11666 }
11667 return resultobj;
11668 fail:
11669 return NULL;
11670 }
11671
11672
11673 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj;
11675 wxJoystick *arg1 = (wxJoystick *) 0 ;
11676 int arg2 ;
11677 PyObject * obj0 = 0 ;
11678 PyObject * obj1 = 0 ;
11679 char *kwnames[] = {
11680 (char *) "self",(char *) "threshold", NULL
11681 };
11682
11683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11685 if (SWIG_arg_fail(1)) SWIG_fail;
11686 {
11687 arg2 = (int)(SWIG_As_int(obj1));
11688 if (SWIG_arg_fail(2)) SWIG_fail;
11689 }
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 (arg1)->SetMovementThreshold(arg2);
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 Py_INCREF(Py_None); resultobj = Py_None;
11698 return resultobj;
11699 fail:
11700 return NULL;
11701 }
11702
11703
11704 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11705 PyObject *resultobj;
11706 wxJoystick *arg1 = (wxJoystick *) 0 ;
11707 bool result;
11708 PyObject * obj0 = 0 ;
11709 char *kwnames[] = {
11710 (char *) "self", NULL
11711 };
11712
11713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11715 if (SWIG_arg_fail(1)) SWIG_fail;
11716 {
11717 PyThreadState* __tstate = wxPyBeginAllowThreads();
11718 result = (bool)(arg1)->IsOk();
11719
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 {
11724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11725 }
11726 return resultobj;
11727 fail:
11728 return NULL;
11729 }
11730
11731
11732 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11733 PyObject *resultobj;
11734 wxJoystick *arg1 = (wxJoystick *) 0 ;
11735 int result;
11736 PyObject * obj0 = 0 ;
11737 char *kwnames[] = {
11738 (char *) "self", NULL
11739 };
11740
11741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11743 if (SWIG_arg_fail(1)) SWIG_fail;
11744 {
11745 PyThreadState* __tstate = wxPyBeginAllowThreads();
11746 result = (int)(arg1)->GetNumberJoysticks();
11747
11748 wxPyEndAllowThreads(__tstate);
11749 if (PyErr_Occurred()) SWIG_fail;
11750 }
11751 {
11752 resultobj = SWIG_From_int((int)(result));
11753 }
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11761 PyObject *resultobj;
11762 wxJoystick *arg1 = (wxJoystick *) 0 ;
11763 int result;
11764 PyObject * obj0 = 0 ;
11765 char *kwnames[] = {
11766 (char *) "self", NULL
11767 };
11768
11769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11771 if (SWIG_arg_fail(1)) SWIG_fail;
11772 {
11773 PyThreadState* __tstate = wxPyBeginAllowThreads();
11774 result = (int)(arg1)->GetManufacturerId();
11775
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 {
11780 resultobj = SWIG_From_int((int)(result));
11781 }
11782 return resultobj;
11783 fail:
11784 return NULL;
11785 }
11786
11787
11788 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11789 PyObject *resultobj;
11790 wxJoystick *arg1 = (wxJoystick *) 0 ;
11791 int result;
11792 PyObject * obj0 = 0 ;
11793 char *kwnames[] = {
11794 (char *) "self", NULL
11795 };
11796
11797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11799 if (SWIG_arg_fail(1)) SWIG_fail;
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 result = (int)(arg1)->GetProductId();
11803
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 resultobj = SWIG_From_int((int)(result));
11809 }
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj;
11818 wxJoystick *arg1 = (wxJoystick *) 0 ;
11819 wxString result;
11820 PyObject * obj0 = 0 ;
11821 char *kwnames[] = {
11822 (char *) "self", NULL
11823 };
11824
11825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11827 if (SWIG_arg_fail(1)) SWIG_fail;
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 result = (arg1)->GetProductName();
11831
11832 wxPyEndAllowThreads(__tstate);
11833 if (PyErr_Occurred()) SWIG_fail;
11834 }
11835 {
11836 #if wxUSE_UNICODE
11837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11838 #else
11839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11840 #endif
11841 }
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11849 PyObject *resultobj;
11850 wxJoystick *arg1 = (wxJoystick *) 0 ;
11851 int result;
11852 PyObject * obj0 = 0 ;
11853 char *kwnames[] = {
11854 (char *) "self", NULL
11855 };
11856
11857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11859 if (SWIG_arg_fail(1)) SWIG_fail;
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 result = (int)(arg1)->GetXMin();
11863
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 {
11868 resultobj = SWIG_From_int((int)(result));
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11877 PyObject *resultobj;
11878 wxJoystick *arg1 = (wxJoystick *) 0 ;
11879 int result;
11880 PyObject * obj0 = 0 ;
11881 char *kwnames[] = {
11882 (char *) "self", NULL
11883 };
11884
11885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11887 if (SWIG_arg_fail(1)) SWIG_fail;
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (int)(arg1)->GetYMin();
11891
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = SWIG_From_int((int)(result));
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj;
11906 wxJoystick *arg1 = (wxJoystick *) 0 ;
11907 int result;
11908 PyObject * obj0 = 0 ;
11909 char *kwnames[] = {
11910 (char *) "self", NULL
11911 };
11912
11913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11915 if (SWIG_arg_fail(1)) SWIG_fail;
11916 {
11917 PyThreadState* __tstate = wxPyBeginAllowThreads();
11918 result = (int)(arg1)->GetZMin();
11919
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 {
11924 resultobj = SWIG_From_int((int)(result));
11925 }
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxJoystick *arg1 = (wxJoystick *) 0 ;
11935 int result;
11936 PyObject * obj0 = 0 ;
11937 char *kwnames[] = {
11938 (char *) "self", NULL
11939 };
11940
11941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11943 if (SWIG_arg_fail(1)) SWIG_fail;
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 result = (int)(arg1)->GetXMax();
11947
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 {
11952 resultobj = SWIG_From_int((int)(result));
11953 }
11954 return resultobj;
11955 fail:
11956 return NULL;
11957 }
11958
11959
11960 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11961 PyObject *resultobj;
11962 wxJoystick *arg1 = (wxJoystick *) 0 ;
11963 int result;
11964 PyObject * obj0 = 0 ;
11965 char *kwnames[] = {
11966 (char *) "self", NULL
11967 };
11968
11969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11971 if (SWIG_arg_fail(1)) SWIG_fail;
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (int)(arg1)->GetYMax();
11975
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 {
11980 resultobj = SWIG_From_int((int)(result));
11981 }
11982 return resultobj;
11983 fail:
11984 return NULL;
11985 }
11986
11987
11988 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11989 PyObject *resultobj;
11990 wxJoystick *arg1 = (wxJoystick *) 0 ;
11991 int result;
11992 PyObject * obj0 = 0 ;
11993 char *kwnames[] = {
11994 (char *) "self", NULL
11995 };
11996
11997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
11998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11999 if (SWIG_arg_fail(1)) SWIG_fail;
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (int)(arg1)->GetZMax();
12003
12004 wxPyEndAllowThreads(__tstate);
12005 if (PyErr_Occurred()) SWIG_fail;
12006 }
12007 {
12008 resultobj = SWIG_From_int((int)(result));
12009 }
12010 return resultobj;
12011 fail:
12012 return NULL;
12013 }
12014
12015
12016 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12017 PyObject *resultobj;
12018 wxJoystick *arg1 = (wxJoystick *) 0 ;
12019 int result;
12020 PyObject * obj0 = 0 ;
12021 char *kwnames[] = {
12022 (char *) "self", NULL
12023 };
12024
12025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12027 if (SWIG_arg_fail(1)) SWIG_fail;
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 result = (int)(arg1)->GetNumberButtons();
12031
12032 wxPyEndAllowThreads(__tstate);
12033 if (PyErr_Occurred()) SWIG_fail;
12034 }
12035 {
12036 resultobj = SWIG_From_int((int)(result));
12037 }
12038 return resultobj;
12039 fail:
12040 return NULL;
12041 }
12042
12043
12044 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12045 PyObject *resultobj;
12046 wxJoystick *arg1 = (wxJoystick *) 0 ;
12047 int result;
12048 PyObject * obj0 = 0 ;
12049 char *kwnames[] = {
12050 (char *) "self", NULL
12051 };
12052
12053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12055 if (SWIG_arg_fail(1)) SWIG_fail;
12056 {
12057 PyThreadState* __tstate = wxPyBeginAllowThreads();
12058 result = (int)(arg1)->GetNumberAxes();
12059
12060 wxPyEndAllowThreads(__tstate);
12061 if (PyErr_Occurred()) SWIG_fail;
12062 }
12063 {
12064 resultobj = SWIG_From_int((int)(result));
12065 }
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj;
12074 wxJoystick *arg1 = (wxJoystick *) 0 ;
12075 int result;
12076 PyObject * obj0 = 0 ;
12077 char *kwnames[] = {
12078 (char *) "self", NULL
12079 };
12080
12081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12083 if (SWIG_arg_fail(1)) SWIG_fail;
12084 {
12085 PyThreadState* __tstate = wxPyBeginAllowThreads();
12086 result = (int)(arg1)->GetMaxButtons();
12087
12088 wxPyEndAllowThreads(__tstate);
12089 if (PyErr_Occurred()) SWIG_fail;
12090 }
12091 {
12092 resultobj = SWIG_From_int((int)(result));
12093 }
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj;
12102 wxJoystick *arg1 = (wxJoystick *) 0 ;
12103 int result;
12104 PyObject * obj0 = 0 ;
12105 char *kwnames[] = {
12106 (char *) "self", NULL
12107 };
12108
12109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12111 if (SWIG_arg_fail(1)) SWIG_fail;
12112 {
12113 PyThreadState* __tstate = wxPyBeginAllowThreads();
12114 result = (int)(arg1)->GetMaxAxes();
12115
12116 wxPyEndAllowThreads(__tstate);
12117 if (PyErr_Occurred()) SWIG_fail;
12118 }
12119 {
12120 resultobj = SWIG_From_int((int)(result));
12121 }
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12129 PyObject *resultobj;
12130 wxJoystick *arg1 = (wxJoystick *) 0 ;
12131 int result;
12132 PyObject * obj0 = 0 ;
12133 char *kwnames[] = {
12134 (char *) "self", NULL
12135 };
12136
12137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12139 if (SWIG_arg_fail(1)) SWIG_fail;
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 result = (int)(arg1)->GetPollingMin();
12143
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 {
12148 resultobj = SWIG_From_int((int)(result));
12149 }
12150 return resultobj;
12151 fail:
12152 return NULL;
12153 }
12154
12155
12156 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12157 PyObject *resultobj;
12158 wxJoystick *arg1 = (wxJoystick *) 0 ;
12159 int result;
12160 PyObject * obj0 = 0 ;
12161 char *kwnames[] = {
12162 (char *) "self", NULL
12163 };
12164
12165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12167 if (SWIG_arg_fail(1)) SWIG_fail;
12168 {
12169 PyThreadState* __tstate = wxPyBeginAllowThreads();
12170 result = (int)(arg1)->GetPollingMax();
12171
12172 wxPyEndAllowThreads(__tstate);
12173 if (PyErr_Occurred()) SWIG_fail;
12174 }
12175 {
12176 resultobj = SWIG_From_int((int)(result));
12177 }
12178 return resultobj;
12179 fail:
12180 return NULL;
12181 }
12182
12183
12184 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12185 PyObject *resultobj;
12186 wxJoystick *arg1 = (wxJoystick *) 0 ;
12187 int result;
12188 PyObject * obj0 = 0 ;
12189 char *kwnames[] = {
12190 (char *) "self", NULL
12191 };
12192
12193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12195 if (SWIG_arg_fail(1)) SWIG_fail;
12196 {
12197 PyThreadState* __tstate = wxPyBeginAllowThreads();
12198 result = (int)(arg1)->GetRudderMin();
12199
12200 wxPyEndAllowThreads(__tstate);
12201 if (PyErr_Occurred()) SWIG_fail;
12202 }
12203 {
12204 resultobj = SWIG_From_int((int)(result));
12205 }
12206 return resultobj;
12207 fail:
12208 return NULL;
12209 }
12210
12211
12212 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12213 PyObject *resultobj;
12214 wxJoystick *arg1 = (wxJoystick *) 0 ;
12215 int result;
12216 PyObject * obj0 = 0 ;
12217 char *kwnames[] = {
12218 (char *) "self", NULL
12219 };
12220
12221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12223 if (SWIG_arg_fail(1)) SWIG_fail;
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 result = (int)(arg1)->GetRudderMax();
12227
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 {
12232 resultobj = SWIG_From_int((int)(result));
12233 }
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj;
12242 wxJoystick *arg1 = (wxJoystick *) 0 ;
12243 int result;
12244 PyObject * obj0 = 0 ;
12245 char *kwnames[] = {
12246 (char *) "self", NULL
12247 };
12248
12249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12251 if (SWIG_arg_fail(1)) SWIG_fail;
12252 {
12253 PyThreadState* __tstate = wxPyBeginAllowThreads();
12254 result = (int)(arg1)->GetUMin();
12255
12256 wxPyEndAllowThreads(__tstate);
12257 if (PyErr_Occurred()) SWIG_fail;
12258 }
12259 {
12260 resultobj = SWIG_From_int((int)(result));
12261 }
12262 return resultobj;
12263 fail:
12264 return NULL;
12265 }
12266
12267
12268 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12269 PyObject *resultobj;
12270 wxJoystick *arg1 = (wxJoystick *) 0 ;
12271 int result;
12272 PyObject * obj0 = 0 ;
12273 char *kwnames[] = {
12274 (char *) "self", NULL
12275 };
12276
12277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12279 if (SWIG_arg_fail(1)) SWIG_fail;
12280 {
12281 PyThreadState* __tstate = wxPyBeginAllowThreads();
12282 result = (int)(arg1)->GetUMax();
12283
12284 wxPyEndAllowThreads(__tstate);
12285 if (PyErr_Occurred()) SWIG_fail;
12286 }
12287 {
12288 resultobj = SWIG_From_int((int)(result));
12289 }
12290 return resultobj;
12291 fail:
12292 return NULL;
12293 }
12294
12295
12296 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj;
12298 wxJoystick *arg1 = (wxJoystick *) 0 ;
12299 int result;
12300 PyObject * obj0 = 0 ;
12301 char *kwnames[] = {
12302 (char *) "self", NULL
12303 };
12304
12305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12307 if (SWIG_arg_fail(1)) SWIG_fail;
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 result = (int)(arg1)->GetVMin();
12311
12312 wxPyEndAllowThreads(__tstate);
12313 if (PyErr_Occurred()) SWIG_fail;
12314 }
12315 {
12316 resultobj = SWIG_From_int((int)(result));
12317 }
12318 return resultobj;
12319 fail:
12320 return NULL;
12321 }
12322
12323
12324 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12325 PyObject *resultobj;
12326 wxJoystick *arg1 = (wxJoystick *) 0 ;
12327 int result;
12328 PyObject * obj0 = 0 ;
12329 char *kwnames[] = {
12330 (char *) "self", NULL
12331 };
12332
12333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12335 if (SWIG_arg_fail(1)) SWIG_fail;
12336 {
12337 PyThreadState* __tstate = wxPyBeginAllowThreads();
12338 result = (int)(arg1)->GetVMax();
12339
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 {
12344 resultobj = SWIG_From_int((int)(result));
12345 }
12346 return resultobj;
12347 fail:
12348 return NULL;
12349 }
12350
12351
12352 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12353 PyObject *resultobj;
12354 wxJoystick *arg1 = (wxJoystick *) 0 ;
12355 bool result;
12356 PyObject * obj0 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 result = (bool)(arg1)->HasRudder();
12367
12368 wxPyEndAllowThreads(__tstate);
12369 if (PyErr_Occurred()) SWIG_fail;
12370 }
12371 {
12372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12373 }
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12381 PyObject *resultobj;
12382 wxJoystick *arg1 = (wxJoystick *) 0 ;
12383 bool result;
12384 PyObject * obj0 = 0 ;
12385 char *kwnames[] = {
12386 (char *) "self", NULL
12387 };
12388
12389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12391 if (SWIG_arg_fail(1)) SWIG_fail;
12392 {
12393 PyThreadState* __tstate = wxPyBeginAllowThreads();
12394 result = (bool)(arg1)->HasZ();
12395
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 {
12400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12401 }
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12409 PyObject *resultobj;
12410 wxJoystick *arg1 = (wxJoystick *) 0 ;
12411 bool result;
12412 PyObject * obj0 = 0 ;
12413 char *kwnames[] = {
12414 (char *) "self", NULL
12415 };
12416
12417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12419 if (SWIG_arg_fail(1)) SWIG_fail;
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 result = (bool)(arg1)->HasU();
12423
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 {
12428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12429 }
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12437 PyObject *resultobj;
12438 wxJoystick *arg1 = (wxJoystick *) 0 ;
12439 bool result;
12440 PyObject * obj0 = 0 ;
12441 char *kwnames[] = {
12442 (char *) "self", NULL
12443 };
12444
12445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12447 if (SWIG_arg_fail(1)) SWIG_fail;
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 result = (bool)(arg1)->HasV();
12451
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 {
12456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12465 PyObject *resultobj;
12466 wxJoystick *arg1 = (wxJoystick *) 0 ;
12467 bool result;
12468 PyObject * obj0 = 0 ;
12469 char *kwnames[] = {
12470 (char *) "self", NULL
12471 };
12472
12473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12475 if (SWIG_arg_fail(1)) SWIG_fail;
12476 {
12477 PyThreadState* __tstate = wxPyBeginAllowThreads();
12478 result = (bool)(arg1)->HasPOV();
12479
12480 wxPyEndAllowThreads(__tstate);
12481 if (PyErr_Occurred()) SWIG_fail;
12482 }
12483 {
12484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12485 }
12486 return resultobj;
12487 fail:
12488 return NULL;
12489 }
12490
12491
12492 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12493 PyObject *resultobj;
12494 wxJoystick *arg1 = (wxJoystick *) 0 ;
12495 bool result;
12496 PyObject * obj0 = 0 ;
12497 char *kwnames[] = {
12498 (char *) "self", NULL
12499 };
12500
12501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12503 if (SWIG_arg_fail(1)) SWIG_fail;
12504 {
12505 PyThreadState* __tstate = wxPyBeginAllowThreads();
12506 result = (bool)(arg1)->HasPOV4Dir();
12507
12508 wxPyEndAllowThreads(__tstate);
12509 if (PyErr_Occurred()) SWIG_fail;
12510 }
12511 {
12512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12513 }
12514 return resultobj;
12515 fail:
12516 return NULL;
12517 }
12518
12519
12520 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj;
12522 wxJoystick *arg1 = (wxJoystick *) 0 ;
12523 bool result;
12524 PyObject * obj0 = 0 ;
12525 char *kwnames[] = {
12526 (char *) "self", NULL
12527 };
12528
12529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12531 if (SWIG_arg_fail(1)) SWIG_fail;
12532 {
12533 PyThreadState* __tstate = wxPyBeginAllowThreads();
12534 result = (bool)(arg1)->HasPOVCTS();
12535
12536 wxPyEndAllowThreads(__tstate);
12537 if (PyErr_Occurred()) SWIG_fail;
12538 }
12539 {
12540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12541 }
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12549 PyObject *resultobj;
12550 wxJoystick *arg1 = (wxJoystick *) 0 ;
12551 wxWindow *arg2 = (wxWindow *) 0 ;
12552 int arg3 = (int) 0 ;
12553 bool result;
12554 PyObject * obj0 = 0 ;
12555 PyObject * obj1 = 0 ;
12556 PyObject * obj2 = 0 ;
12557 char *kwnames[] = {
12558 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12559 };
12560
12561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12563 if (SWIG_arg_fail(1)) SWIG_fail;
12564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12565 if (SWIG_arg_fail(2)) SWIG_fail;
12566 if (obj2) {
12567 {
12568 arg3 = (int)(SWIG_As_int(obj2));
12569 if (SWIG_arg_fail(3)) SWIG_fail;
12570 }
12571 }
12572 {
12573 PyThreadState* __tstate = wxPyBeginAllowThreads();
12574 result = (bool)(arg1)->SetCapture(arg2,arg3);
12575
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 {
12580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12581 }
12582 return resultobj;
12583 fail:
12584 return NULL;
12585 }
12586
12587
12588 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj;
12590 wxJoystick *arg1 = (wxJoystick *) 0 ;
12591 bool result;
12592 PyObject * obj0 = 0 ;
12593 char *kwnames[] = {
12594 (char *) "self", NULL
12595 };
12596
12597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12599 if (SWIG_arg_fail(1)) SWIG_fail;
12600 {
12601 PyThreadState* __tstate = wxPyBeginAllowThreads();
12602 result = (bool)(arg1)->ReleaseCapture();
12603
12604 wxPyEndAllowThreads(__tstate);
12605 if (PyErr_Occurred()) SWIG_fail;
12606 }
12607 {
12608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12609 }
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12617 PyObject *obj;
12618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12619 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12620 Py_INCREF(obj);
12621 return Py_BuildValue((char *)"");
12622 }
12623 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12624 PyObject *resultobj;
12625 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12626 int arg2 = (int) 0 ;
12627 int arg3 = (int) wxJOYSTICK1 ;
12628 int arg4 = (int) 0 ;
12629 wxJoystickEvent *result;
12630 PyObject * obj0 = 0 ;
12631 PyObject * obj1 = 0 ;
12632 PyObject * obj2 = 0 ;
12633 PyObject * obj3 = 0 ;
12634 char *kwnames[] = {
12635 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12636 };
12637
12638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12639 if (obj0) {
12640 {
12641 arg1 = (wxEventType)(SWIG_As_int(obj0));
12642 if (SWIG_arg_fail(1)) SWIG_fail;
12643 }
12644 }
12645 if (obj1) {
12646 {
12647 arg2 = (int)(SWIG_As_int(obj1));
12648 if (SWIG_arg_fail(2)) SWIG_fail;
12649 }
12650 }
12651 if (obj2) {
12652 {
12653 arg3 = (int)(SWIG_As_int(obj2));
12654 if (SWIG_arg_fail(3)) SWIG_fail;
12655 }
12656 }
12657 if (obj3) {
12658 {
12659 arg4 = (int)(SWIG_As_int(obj3));
12660 if (SWIG_arg_fail(4)) SWIG_fail;
12661 }
12662 }
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12666
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12671 return resultobj;
12672 fail:
12673 return NULL;
12674 }
12675
12676
12677 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12678 PyObject *resultobj;
12679 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12680 wxPoint result;
12681 PyObject * obj0 = 0 ;
12682 char *kwnames[] = {
12683 (char *) "self", NULL
12684 };
12685
12686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12688 if (SWIG_arg_fail(1)) SWIG_fail;
12689 {
12690 PyThreadState* __tstate = wxPyBeginAllowThreads();
12691 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12692
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 {
12697 wxPoint * resultptr;
12698 resultptr = new wxPoint((wxPoint &)(result));
12699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12700 }
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12708 PyObject *resultobj;
12709 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12710 int result;
12711 PyObject * obj0 = 0 ;
12712 char *kwnames[] = {
12713 (char *) "self", NULL
12714 };
12715
12716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12718 if (SWIG_arg_fail(1)) SWIG_fail;
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12722
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 {
12727 resultobj = SWIG_From_int((int)(result));
12728 }
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj;
12737 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12738 int result;
12739 PyObject * obj0 = 0 ;
12740 char *kwnames[] = {
12741 (char *) "self", NULL
12742 };
12743
12744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12746 if (SWIG_arg_fail(1)) SWIG_fail;
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12750
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 {
12755 resultobj = SWIG_From_int((int)(result));
12756 }
12757 return resultobj;
12758 fail:
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj;
12765 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12766 int result;
12767 PyObject * obj0 = 0 ;
12768 char *kwnames[] = {
12769 (char *) "self", NULL
12770 };
12771
12772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12774 if (SWIG_arg_fail(1)) SWIG_fail;
12775 {
12776 PyThreadState* __tstate = wxPyBeginAllowThreads();
12777 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12778
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 {
12783 resultobj = SWIG_From_int((int)(result));
12784 }
12785 return resultobj;
12786 fail:
12787 return NULL;
12788 }
12789
12790
12791 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12792 PyObject *resultobj;
12793 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12794 int result;
12795 PyObject * obj0 = 0 ;
12796 char *kwnames[] = {
12797 (char *) "self", NULL
12798 };
12799
12800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12802 if (SWIG_arg_fail(1)) SWIG_fail;
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12806
12807 wxPyEndAllowThreads(__tstate);
12808 if (PyErr_Occurred()) SWIG_fail;
12809 }
12810 {
12811 resultobj = SWIG_From_int((int)(result));
12812 }
12813 return resultobj;
12814 fail:
12815 return NULL;
12816 }
12817
12818
12819 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12820 PyObject *resultobj;
12821 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12822 int arg2 ;
12823 PyObject * obj0 = 0 ;
12824 PyObject * obj1 = 0 ;
12825 char *kwnames[] = {
12826 (char *) "self",(char *) "stick", NULL
12827 };
12828
12829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12831 if (SWIG_arg_fail(1)) SWIG_fail;
12832 {
12833 arg2 = (int)(SWIG_As_int(obj1));
12834 if (SWIG_arg_fail(2)) SWIG_fail;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 (arg1)->SetJoystick(arg2);
12839
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 Py_INCREF(Py_None); resultobj = Py_None;
12844 return resultobj;
12845 fail:
12846 return NULL;
12847 }
12848
12849
12850 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12851 PyObject *resultobj;
12852 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12853 int arg2 ;
12854 PyObject * obj0 = 0 ;
12855 PyObject * obj1 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self",(char *) "state", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 arg2 = (int)(SWIG_As_int(obj1));
12865 if (SWIG_arg_fail(2)) SWIG_fail;
12866 }
12867 {
12868 PyThreadState* __tstate = wxPyBeginAllowThreads();
12869 (arg1)->SetButtonState(arg2);
12870
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 Py_INCREF(Py_None); resultobj = Py_None;
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12882 PyObject *resultobj;
12883 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12884 int arg2 ;
12885 PyObject * obj0 = 0 ;
12886 PyObject * obj1 = 0 ;
12887 char *kwnames[] = {
12888 (char *) "self",(char *) "change", NULL
12889 };
12890
12891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12893 if (SWIG_arg_fail(1)) SWIG_fail;
12894 {
12895 arg2 = (int)(SWIG_As_int(obj1));
12896 if (SWIG_arg_fail(2)) SWIG_fail;
12897 }
12898 {
12899 PyThreadState* __tstate = wxPyBeginAllowThreads();
12900 (arg1)->SetButtonChange(arg2);
12901
12902 wxPyEndAllowThreads(__tstate);
12903 if (PyErr_Occurred()) SWIG_fail;
12904 }
12905 Py_INCREF(Py_None); resultobj = Py_None;
12906 return resultobj;
12907 fail:
12908 return NULL;
12909 }
12910
12911
12912 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj;
12914 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12915 wxPoint *arg2 = 0 ;
12916 wxPoint temp2 ;
12917 PyObject * obj0 = 0 ;
12918 PyObject * obj1 = 0 ;
12919 char *kwnames[] = {
12920 (char *) "self",(char *) "pos", NULL
12921 };
12922
12923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12925 if (SWIG_arg_fail(1)) SWIG_fail;
12926 {
12927 arg2 = &temp2;
12928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12929 }
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 (arg1)->SetPosition((wxPoint const &)*arg2);
12933
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 Py_INCREF(Py_None); resultobj = Py_None;
12938 return resultobj;
12939 fail:
12940 return NULL;
12941 }
12942
12943
12944 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12945 PyObject *resultobj;
12946 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12947 int arg2 ;
12948 PyObject * obj0 = 0 ;
12949 PyObject * obj1 = 0 ;
12950 char *kwnames[] = {
12951 (char *) "self",(char *) "zPos", NULL
12952 };
12953
12954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12956 if (SWIG_arg_fail(1)) SWIG_fail;
12957 {
12958 arg2 = (int)(SWIG_As_int(obj1));
12959 if (SWIG_arg_fail(2)) SWIG_fail;
12960 }
12961 {
12962 PyThreadState* __tstate = wxPyBeginAllowThreads();
12963 (arg1)->SetZPosition(arg2);
12964
12965 wxPyEndAllowThreads(__tstate);
12966 if (PyErr_Occurred()) SWIG_fail;
12967 }
12968 Py_INCREF(Py_None); resultobj = Py_None;
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12976 PyObject *resultobj;
12977 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12978 bool result;
12979 PyObject * obj0 = 0 ;
12980 char *kwnames[] = {
12981 (char *) "self", NULL
12982 };
12983
12984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12986 if (SWIG_arg_fail(1)) SWIG_fail;
12987 {
12988 PyThreadState* __tstate = wxPyBeginAllowThreads();
12989 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
12990
12991 wxPyEndAllowThreads(__tstate);
12992 if (PyErr_Occurred()) SWIG_fail;
12993 }
12994 {
12995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12996 }
12997 return resultobj;
12998 fail:
12999 return NULL;
13000 }
13001
13002
13003 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13004 PyObject *resultobj;
13005 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13006 bool result;
13007 PyObject * obj0 = 0 ;
13008 char *kwnames[] = {
13009 (char *) "self", NULL
13010 };
13011
13012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13014 if (SWIG_arg_fail(1)) SWIG_fail;
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13018
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 {
13023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13024 }
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13034 bool result;
13035 PyObject * obj0 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13042 if (SWIG_arg_fail(1)) SWIG_fail;
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13052 }
13053 return resultobj;
13054 fail:
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj;
13061 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13062 int arg2 = (int) wxJOY_BUTTON_ANY ;
13063 bool result;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 char *kwnames[] = {
13067 (char *) "self",(char *) "but", NULL
13068 };
13069
13070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13072 if (SWIG_arg_fail(1)) SWIG_fail;
13073 if (obj1) {
13074 {
13075 arg2 = (int)(SWIG_As_int(obj1));
13076 if (SWIG_arg_fail(2)) SWIG_fail;
13077 }
13078 }
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 {
13087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13088 }
13089 return resultobj;
13090 fail:
13091 return NULL;
13092 }
13093
13094
13095 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13096 PyObject *resultobj;
13097 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13098 int arg2 = (int) wxJOY_BUTTON_ANY ;
13099 bool result;
13100 PyObject * obj0 = 0 ;
13101 PyObject * obj1 = 0 ;
13102 char *kwnames[] = {
13103 (char *) "self",(char *) "but", NULL
13104 };
13105
13106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13108 if (SWIG_arg_fail(1)) SWIG_fail;
13109 if (obj1) {
13110 {
13111 arg2 = (int)(SWIG_As_int(obj1));
13112 if (SWIG_arg_fail(2)) SWIG_fail;
13113 }
13114 }
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13118
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 {
13123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13124 }
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj;
13133 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13134 int arg2 = (int) wxJOY_BUTTON_ANY ;
13135 bool result;
13136 PyObject * obj0 = 0 ;
13137 PyObject * obj1 = 0 ;
13138 char *kwnames[] = {
13139 (char *) "self",(char *) "but", NULL
13140 };
13141
13142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13144 if (SWIG_arg_fail(1)) SWIG_fail;
13145 if (obj1) {
13146 {
13147 arg2 = (int)(SWIG_As_int(obj1));
13148 if (SWIG_arg_fail(2)) SWIG_fail;
13149 }
13150 }
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13168 PyObject *obj;
13169 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13170 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13171 Py_INCREF(obj);
13172 return Py_BuildValue((char *)"");
13173 }
13174 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13175 PyObject *resultobj;
13176 wxString const &arg1_defvalue = wxPyEmptyString ;
13177 wxString *arg1 = (wxString *) &arg1_defvalue ;
13178 wxSound *result;
13179 bool temp1 = false ;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "fileName", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13186 if (obj0) {
13187 {
13188 arg1 = wxString_in_helper(obj0);
13189 if (arg1 == NULL) SWIG_fail;
13190 temp1 = true;
13191 }
13192 }
13193 {
13194 if (!wxPyCheckForApp()) SWIG_fail;
13195 PyThreadState* __tstate = wxPyBeginAllowThreads();
13196 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13197
13198 wxPyEndAllowThreads(__tstate);
13199 if (PyErr_Occurred()) SWIG_fail;
13200 }
13201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13202 {
13203 if (temp1)
13204 delete arg1;
13205 }
13206 return resultobj;
13207 fail:
13208 {
13209 if (temp1)
13210 delete arg1;
13211 }
13212 return NULL;
13213 }
13214
13215
13216 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13217 PyObject *resultobj;
13218 PyObject *arg1 = (PyObject *) 0 ;
13219 wxSound *result;
13220 PyObject * obj0 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "data", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13226 arg1 = obj0;
13227 {
13228 if (!wxPyCheckForApp()) SWIG_fail;
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (wxSound *)new_wxSound(arg1);
13231
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13236 return resultobj;
13237 fail:
13238 return NULL;
13239 }
13240
13241
13242 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj;
13244 wxSound *arg1 = (wxSound *) 0 ;
13245 PyObject * obj0 = 0 ;
13246 char *kwnames[] = {
13247 (char *) "self", NULL
13248 };
13249
13250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13252 if (SWIG_arg_fail(1)) SWIG_fail;
13253 {
13254 PyThreadState* __tstate = wxPyBeginAllowThreads();
13255 delete arg1;
13256
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 Py_INCREF(Py_None); resultobj = Py_None;
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj;
13269 wxSound *arg1 = (wxSound *) 0 ;
13270 wxString *arg2 = 0 ;
13271 bool result;
13272 bool temp2 = false ;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 char *kwnames[] = {
13276 (char *) "self",(char *) "fileName", NULL
13277 };
13278
13279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13281 if (SWIG_arg_fail(1)) SWIG_fail;
13282 {
13283 arg2 = wxString_in_helper(obj1);
13284 if (arg2 == NULL) SWIG_fail;
13285 temp2 = true;
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (bool)(arg1)->Create((wxString const &)*arg2);
13290
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 {
13295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13296 }
13297 {
13298 if (temp2)
13299 delete arg2;
13300 }
13301 return resultobj;
13302 fail:
13303 {
13304 if (temp2)
13305 delete arg2;
13306 }
13307 return NULL;
13308 }
13309
13310
13311 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj;
13313 wxSound *arg1 = (wxSound *) 0 ;
13314 PyObject *arg2 = (PyObject *) 0 ;
13315 bool result;
13316 PyObject * obj0 = 0 ;
13317 PyObject * obj1 = 0 ;
13318 char *kwnames[] = {
13319 (char *) "self",(char *) "data", NULL
13320 };
13321
13322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13324 if (SWIG_arg_fail(1)) SWIG_fail;
13325 arg2 = obj1;
13326 {
13327 PyThreadState* __tstate = wxPyBeginAllowThreads();
13328 result = (bool)wxSound_CreateFromData(arg1,arg2);
13329
13330 wxPyEndAllowThreads(__tstate);
13331 if (PyErr_Occurred()) SWIG_fail;
13332 }
13333 {
13334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13335 }
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj;
13344 wxSound *arg1 = (wxSound *) 0 ;
13345 bool result;
13346 PyObject * obj0 = 0 ;
13347 char *kwnames[] = {
13348 (char *) "self", NULL
13349 };
13350
13351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13353 if (SWIG_arg_fail(1)) SWIG_fail;
13354 {
13355 PyThreadState* __tstate = wxPyBeginAllowThreads();
13356 result = (bool)(arg1)->IsOk();
13357
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 {
13362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13363 }
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13371 PyObject *resultobj;
13372 wxSound *arg1 = (wxSound *) 0 ;
13373 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13374 bool result;
13375 PyObject * obj0 = 0 ;
13376 PyObject * obj1 = 0 ;
13377 char *kwnames[] = {
13378 (char *) "self",(char *) "flags", NULL
13379 };
13380
13381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13383 if (SWIG_arg_fail(1)) SWIG_fail;
13384 if (obj1) {
13385 {
13386 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13387 if (SWIG_arg_fail(2)) SWIG_fail;
13388 }
13389 }
13390 {
13391 if (!wxPyCheckForApp()) SWIG_fail;
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 result = (bool)((wxSound const *)arg1)->Play(arg2);
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 {
13399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13400 }
13401 return resultobj;
13402 fail:
13403 return NULL;
13404 }
13405
13406
13407 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13408 PyObject *resultobj;
13409 wxString *arg1 = 0 ;
13410 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13411 bool result;
13412 bool temp1 = false ;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13415 char *kwnames[] = {
13416 (char *) "filename",(char *) "flags", NULL
13417 };
13418
13419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13420 {
13421 arg1 = wxString_in_helper(obj0);
13422 if (arg1 == NULL) SWIG_fail;
13423 temp1 = true;
13424 }
13425 if (obj1) {
13426 {
13427 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13428 if (SWIG_arg_fail(2)) SWIG_fail;
13429 }
13430 }
13431 {
13432 if (!wxPyCheckForApp()) SWIG_fail;
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13435
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 {
13440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13441 }
13442 {
13443 if (temp1)
13444 delete arg1;
13445 }
13446 return resultobj;
13447 fail:
13448 {
13449 if (temp1)
13450 delete arg1;
13451 }
13452 return NULL;
13453 }
13454
13455
13456 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13457 PyObject *resultobj;
13458 char *kwnames[] = {
13459 NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13463 {
13464 if (!wxPyCheckForApp()) SWIG_fail;
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 wxSound::Stop();
13467
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 Py_INCREF(Py_None); resultobj = Py_None;
13472 return resultobj;
13473 fail:
13474 return NULL;
13475 }
13476
13477
13478 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13479 PyObject *obj;
13480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13481 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13482 Py_INCREF(obj);
13483 return Py_BuildValue((char *)"");
13484 }
13485 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj;
13487 wxString *arg1 = 0 ;
13488 wxString *arg2 = 0 ;
13489 wxString *arg3 = 0 ;
13490 wxString *arg4 = 0 ;
13491 wxFileTypeInfo *result;
13492 bool temp1 = false ;
13493 bool temp2 = false ;
13494 bool temp3 = false ;
13495 bool temp4 = false ;
13496 PyObject * obj0 = 0 ;
13497 PyObject * obj1 = 0 ;
13498 PyObject * obj2 = 0 ;
13499 PyObject * obj3 = 0 ;
13500 char *kwnames[] = {
13501 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13502 };
13503
13504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13505 {
13506 arg1 = wxString_in_helper(obj0);
13507 if (arg1 == NULL) SWIG_fail;
13508 temp1 = true;
13509 }
13510 {
13511 arg2 = wxString_in_helper(obj1);
13512 if (arg2 == NULL) SWIG_fail;
13513 temp2 = true;
13514 }
13515 {
13516 arg3 = wxString_in_helper(obj2);
13517 if (arg3 == NULL) SWIG_fail;
13518 temp3 = true;
13519 }
13520 {
13521 arg4 = wxString_in_helper(obj3);
13522 if (arg4 == NULL) SWIG_fail;
13523 temp4 = true;
13524 }
13525 {
13526 PyThreadState* __tstate = wxPyBeginAllowThreads();
13527 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13528
13529 wxPyEndAllowThreads(__tstate);
13530 if (PyErr_Occurred()) SWIG_fail;
13531 }
13532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13533 {
13534 if (temp1)
13535 delete arg1;
13536 }
13537 {
13538 if (temp2)
13539 delete arg2;
13540 }
13541 {
13542 if (temp3)
13543 delete arg3;
13544 }
13545 {
13546 if (temp4)
13547 delete arg4;
13548 }
13549 return resultobj;
13550 fail:
13551 {
13552 if (temp1)
13553 delete arg1;
13554 }
13555 {
13556 if (temp2)
13557 delete arg2;
13558 }
13559 {
13560 if (temp3)
13561 delete arg3;
13562 }
13563 {
13564 if (temp4)
13565 delete arg4;
13566 }
13567 return NULL;
13568 }
13569
13570
13571 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj;
13573 wxArrayString *arg1 = 0 ;
13574 wxFileTypeInfo *result;
13575 bool temp1 = false ;
13576 PyObject * obj0 = 0 ;
13577 char *kwnames[] = {
13578 (char *) "sArray", NULL
13579 };
13580
13581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13582 {
13583 if (! PySequence_Check(obj0)) {
13584 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13585 SWIG_fail;
13586 }
13587 arg1 = new wxArrayString;
13588 temp1 = true;
13589 int i, len=PySequence_Length(obj0);
13590 for (i=0; i<len; i++) {
13591 PyObject* item = PySequence_GetItem(obj0, i);
13592 #if wxUSE_UNICODE
13593 PyObject* str = PyObject_Unicode(item);
13594 #else
13595 PyObject* str = PyObject_Str(item);
13596 #endif
13597 if (PyErr_Occurred()) SWIG_fail;
13598 arg1->Add(Py2wxString(str));
13599 Py_DECREF(item);
13600 Py_DECREF(str);
13601 }
13602 }
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13606
13607 wxPyEndAllowThreads(__tstate);
13608 if (PyErr_Occurred()) SWIG_fail;
13609 }
13610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13611 {
13612 if (temp1) delete arg1;
13613 }
13614 return resultobj;
13615 fail:
13616 {
13617 if (temp1) delete arg1;
13618 }
13619 return NULL;
13620 }
13621
13622
13623 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13624 PyObject *resultobj;
13625 wxFileTypeInfo *result;
13626 char *kwnames[] = {
13627 NULL
13628 };
13629
13630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13634
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj;
13647 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13648 bool result;
13649 PyObject * obj0 = 0 ;
13650 char *kwnames[] = {
13651 (char *) "self", NULL
13652 };
13653
13654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13656 if (SWIG_arg_fail(1)) SWIG_fail;
13657 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13660
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 {
13665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13666 }
13667 return resultobj;
13668 fail:
13669 return NULL;
13670 }
13671
13672
13673 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13674 PyObject *resultobj;
13675 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13676 wxString *arg2 = 0 ;
13677 int arg3 = (int) 0 ;
13678 bool temp2 = false ;
13679 PyObject * obj0 = 0 ;
13680 PyObject * obj1 = 0 ;
13681 PyObject * obj2 = 0 ;
13682 char *kwnames[] = {
13683 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13684 };
13685
13686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13688 if (SWIG_arg_fail(1)) SWIG_fail;
13689 {
13690 arg2 = wxString_in_helper(obj1);
13691 if (arg2 == NULL) SWIG_fail;
13692 temp2 = true;
13693 }
13694 if (obj2) {
13695 {
13696 arg3 = (int)(SWIG_As_int(obj2));
13697 if (SWIG_arg_fail(3)) SWIG_fail;
13698 }
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13703
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 Py_INCREF(Py_None); resultobj = Py_None;
13708 {
13709 if (temp2)
13710 delete arg2;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp2)
13716 delete arg2;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj;
13724 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13725 wxString *arg2 = 0 ;
13726 bool temp2 = false ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 char *kwnames[] = {
13730 (char *) "self",(char *) "shortDesc", NULL
13731 };
13732
13733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13735 if (SWIG_arg_fail(1)) SWIG_fail;
13736 {
13737 arg2 = wxString_in_helper(obj1);
13738 if (arg2 == NULL) SWIG_fail;
13739 temp2 = true;
13740 }
13741 {
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 (arg1)->SetShortDesc((wxString const &)*arg2);
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 Py_INCREF(Py_None); resultobj = Py_None;
13749 {
13750 if (temp2)
13751 delete arg2;
13752 }
13753 return resultobj;
13754 fail:
13755 {
13756 if (temp2)
13757 delete arg2;
13758 }
13759 return NULL;
13760 }
13761
13762
13763 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj;
13765 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13766 wxString *result;
13767 PyObject * obj0 = 0 ;
13768 char *kwnames[] = {
13769 (char *) "self", NULL
13770 };
13771
13772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13774 if (SWIG_arg_fail(1)) SWIG_fail;
13775 {
13776 PyThreadState* __tstate = wxPyBeginAllowThreads();
13777 {
13778 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13779 result = (wxString *) &_result_ref;
13780 }
13781
13782 wxPyEndAllowThreads(__tstate);
13783 if (PyErr_Occurred()) SWIG_fail;
13784 }
13785 {
13786 #if wxUSE_UNICODE
13787 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13788 #else
13789 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13790 #endif
13791 }
13792 return resultobj;
13793 fail:
13794 return NULL;
13795 }
13796
13797
13798 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13799 PyObject *resultobj;
13800 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13801 wxString *result;
13802 PyObject * obj0 = 0 ;
13803 char *kwnames[] = {
13804 (char *) "self", NULL
13805 };
13806
13807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13809 if (SWIG_arg_fail(1)) SWIG_fail;
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 {
13813 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13814 result = (wxString *) &_result_ref;
13815 }
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 {
13821 #if wxUSE_UNICODE
13822 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13823 #else
13824 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13825 #endif
13826 }
13827 return resultobj;
13828 fail:
13829 return NULL;
13830 }
13831
13832
13833 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13834 PyObject *resultobj;
13835 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13836 wxString *result;
13837 PyObject * obj0 = 0 ;
13838 char *kwnames[] = {
13839 (char *) "self", NULL
13840 };
13841
13842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13844 if (SWIG_arg_fail(1)) SWIG_fail;
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 {
13848 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13849 result = (wxString *) &_result_ref;
13850 }
13851
13852 wxPyEndAllowThreads(__tstate);
13853 if (PyErr_Occurred()) SWIG_fail;
13854 }
13855 {
13856 #if wxUSE_UNICODE
13857 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13858 #else
13859 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13860 #endif
13861 }
13862 return resultobj;
13863 fail:
13864 return NULL;
13865 }
13866
13867
13868 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13869 PyObject *resultobj;
13870 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13871 wxString *result;
13872 PyObject * obj0 = 0 ;
13873 char *kwnames[] = {
13874 (char *) "self", NULL
13875 };
13876
13877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13879 if (SWIG_arg_fail(1)) SWIG_fail;
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 {
13883 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13884 result = (wxString *) &_result_ref;
13885 }
13886
13887 wxPyEndAllowThreads(__tstate);
13888 if (PyErr_Occurred()) SWIG_fail;
13889 }
13890 {
13891 #if wxUSE_UNICODE
13892 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13893 #else
13894 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13895 #endif
13896 }
13897 return resultobj;
13898 fail:
13899 return NULL;
13900 }
13901
13902
13903 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13904 PyObject *resultobj;
13905 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13906 wxString *result;
13907 PyObject * obj0 = 0 ;
13908 char *kwnames[] = {
13909 (char *) "self", NULL
13910 };
13911
13912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13914 if (SWIG_arg_fail(1)) SWIG_fail;
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 {
13918 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13919 result = (wxString *) &_result_ref;
13920 }
13921
13922 wxPyEndAllowThreads(__tstate);
13923 if (PyErr_Occurred()) SWIG_fail;
13924 }
13925 {
13926 #if wxUSE_UNICODE
13927 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13928 #else
13929 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13930 #endif
13931 }
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj;
13940 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13941 wxArrayString *result;
13942 PyObject * obj0 = 0 ;
13943 char *kwnames[] = {
13944 (char *) "self", NULL
13945 };
13946
13947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13949 if (SWIG_arg_fail(1)) SWIG_fail;
13950 {
13951 PyThreadState* __tstate = wxPyBeginAllowThreads();
13952 {
13953 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13954 result = (wxArrayString *) &_result_ref;
13955 }
13956
13957 wxPyEndAllowThreads(__tstate);
13958 if (PyErr_Occurred()) SWIG_fail;
13959 }
13960 {
13961 resultobj = wxArrayString2PyList_helper(*result);
13962 }
13963 return resultobj;
13964 fail:
13965 return NULL;
13966 }
13967
13968
13969 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13970 PyObject *resultobj;
13971 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13972 int result;
13973 PyObject * obj0 = 0 ;
13974 char *kwnames[] = {
13975 (char *) "self", NULL
13976 };
13977
13978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13980 if (SWIG_arg_fail(1)) SWIG_fail;
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13984
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 {
13989 resultobj = SWIG_From_int((int)(result));
13990 }
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj;
13999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14000 wxString *result;
14001 PyObject * obj0 = 0 ;
14002 char *kwnames[] = {
14003 (char *) "self", NULL
14004 };
14005
14006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14008 if (SWIG_arg_fail(1)) SWIG_fail;
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 {
14012 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14013 result = (wxString *) &_result_ref;
14014 }
14015
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 {
14020 #if wxUSE_UNICODE
14021 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14022 #else
14023 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14024 #endif
14025 }
14026 return resultobj;
14027 fail:
14028 return NULL;
14029 }
14030
14031
14032 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14033 PyObject *resultobj;
14034 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14035 int result;
14036 PyObject * obj0 = 0 ;
14037 char *kwnames[] = {
14038 (char *) "self", NULL
14039 };
14040
14041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14043 if (SWIG_arg_fail(1)) SWIG_fail;
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14047
14048 wxPyEndAllowThreads(__tstate);
14049 if (PyErr_Occurred()) SWIG_fail;
14050 }
14051 {
14052 resultobj = SWIG_From_int((int)(result));
14053 }
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14061 PyObject *obj;
14062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14063 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14064 Py_INCREF(obj);
14065 return Py_BuildValue((char *)"");
14066 }
14067 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14068 PyObject *resultobj;
14069 wxFileTypeInfo *arg1 = 0 ;
14070 wxFileType *result;
14071 PyObject * obj0 = 0 ;
14072 char *kwnames[] = {
14073 (char *) "ftInfo", NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14077 {
14078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14079 if (SWIG_arg_fail(1)) SWIG_fail;
14080 if (arg1 == NULL) {
14081 SWIG_null_ref("wxFileTypeInfo");
14082 }
14083 if (SWIG_arg_fail(1)) SWIG_fail;
14084 }
14085 {
14086 PyThreadState* __tstate = wxPyBeginAllowThreads();
14087 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14088
14089 wxPyEndAllowThreads(__tstate);
14090 if (PyErr_Occurred()) SWIG_fail;
14091 }
14092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14093 return resultobj;
14094 fail:
14095 return NULL;
14096 }
14097
14098
14099 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14100 PyObject *resultobj;
14101 wxFileType *arg1 = (wxFileType *) 0 ;
14102 PyObject * obj0 = 0 ;
14103 char *kwnames[] = {
14104 (char *) "self", NULL
14105 };
14106
14107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14109 if (SWIG_arg_fail(1)) SWIG_fail;
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 delete arg1;
14113
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 Py_INCREF(Py_None); resultobj = Py_None;
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14125 PyObject *resultobj;
14126 wxFileType *arg1 = (wxFileType *) 0 ;
14127 PyObject *result;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (PyObject *)wxFileType_GetMimeType(arg1);
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 resultobj = result;
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxFileType *arg1 = (wxFileType *) 0 ;
14153 PyObject *result;
14154 PyObject * obj0 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14165
14166 wxPyEndAllowThreads(__tstate);
14167 if (PyErr_Occurred()) SWIG_fail;
14168 }
14169 resultobj = result;
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxFileType *arg1 = (wxFileType *) 0 ;
14179 PyObject *result;
14180 PyObject * obj0 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "self", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14187 if (SWIG_arg_fail(1)) SWIG_fail;
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 result = (PyObject *)wxFileType_GetExtensions(arg1);
14191
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 resultobj = result;
14196 return resultobj;
14197 fail:
14198 return NULL;
14199 }
14200
14201
14202 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14203 PyObject *resultobj;
14204 wxFileType *arg1 = (wxFileType *) 0 ;
14205 wxIcon *result;
14206 PyObject * obj0 = 0 ;
14207 char *kwnames[] = {
14208 (char *) "self", NULL
14209 };
14210
14211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14213 if (SWIG_arg_fail(1)) SWIG_fail;
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (wxIcon *)wxFileType_GetIcon(arg1);
14217
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14222 return resultobj;
14223 fail:
14224 return NULL;
14225 }
14226
14227
14228 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14229 PyObject *resultobj;
14230 wxFileType *arg1 = (wxFileType *) 0 ;
14231 PyObject *result;
14232 PyObject * obj0 = 0 ;
14233 char *kwnames[] = {
14234 (char *) "self", NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14243
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 resultobj = result;
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxFileType *arg1 = (wxFileType *) 0 ;
14257 PyObject *result;
14258 PyObject * obj0 = 0 ;
14259 char *kwnames[] = {
14260 (char *) "self", NULL
14261 };
14262
14263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (PyObject *)wxFileType_GetDescription(arg1);
14269
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 resultobj = result;
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj;
14282 wxFileType *arg1 = (wxFileType *) 0 ;
14283 wxString *arg2 = 0 ;
14284 wxString const &arg3_defvalue = wxPyEmptyString ;
14285 wxString *arg3 = (wxString *) &arg3_defvalue ;
14286 PyObject *result;
14287 bool temp2 = false ;
14288 bool temp3 = false ;
14289 PyObject * obj0 = 0 ;
14290 PyObject * obj1 = 0 ;
14291 PyObject * obj2 = 0 ;
14292 char *kwnames[] = {
14293 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14294 };
14295
14296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14298 if (SWIG_arg_fail(1)) SWIG_fail;
14299 {
14300 arg2 = wxString_in_helper(obj1);
14301 if (arg2 == NULL) SWIG_fail;
14302 temp2 = true;
14303 }
14304 if (obj2) {
14305 {
14306 arg3 = wxString_in_helper(obj2);
14307 if (arg3 == NULL) SWIG_fail;
14308 temp3 = true;
14309 }
14310 }
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14314
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 resultobj = result;
14319 {
14320 if (temp2)
14321 delete arg2;
14322 }
14323 {
14324 if (temp3)
14325 delete arg3;
14326 }
14327 return resultobj;
14328 fail:
14329 {
14330 if (temp2)
14331 delete arg2;
14332 }
14333 {
14334 if (temp3)
14335 delete arg3;
14336 }
14337 return NULL;
14338 }
14339
14340
14341 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj;
14343 wxFileType *arg1 = (wxFileType *) 0 ;
14344 wxString *arg2 = 0 ;
14345 wxString const &arg3_defvalue = wxPyEmptyString ;
14346 wxString *arg3 = (wxString *) &arg3_defvalue ;
14347 PyObject *result;
14348 bool temp2 = false ;
14349 bool temp3 = false ;
14350 PyObject * obj0 = 0 ;
14351 PyObject * obj1 = 0 ;
14352 PyObject * obj2 = 0 ;
14353 char *kwnames[] = {
14354 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14355 };
14356
14357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14359 if (SWIG_arg_fail(1)) SWIG_fail;
14360 {
14361 arg2 = wxString_in_helper(obj1);
14362 if (arg2 == NULL) SWIG_fail;
14363 temp2 = true;
14364 }
14365 if (obj2) {
14366 {
14367 arg3 = wxString_in_helper(obj2);
14368 if (arg3 == NULL) SWIG_fail;
14369 temp3 = true;
14370 }
14371 }
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14375
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = result;
14380 {
14381 if (temp2)
14382 delete arg2;
14383 }
14384 {
14385 if (temp3)
14386 delete arg3;
14387 }
14388 return resultobj;
14389 fail:
14390 {
14391 if (temp2)
14392 delete arg2;
14393 }
14394 {
14395 if (temp3)
14396 delete arg3;
14397 }
14398 return NULL;
14399 }
14400
14401
14402 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14403 PyObject *resultobj;
14404 wxFileType *arg1 = (wxFileType *) 0 ;
14405 wxString *arg2 = 0 ;
14406 wxString const &arg3_defvalue = wxPyEmptyString ;
14407 wxString *arg3 = (wxString *) &arg3_defvalue ;
14408 PyObject *result;
14409 bool temp2 = false ;
14410 bool temp3 = false ;
14411 PyObject * obj0 = 0 ;
14412 PyObject * obj1 = 0 ;
14413 PyObject * obj2 = 0 ;
14414 char *kwnames[] = {
14415 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(1)) SWIG_fail;
14421 {
14422 arg2 = wxString_in_helper(obj1);
14423 if (arg2 == NULL) SWIG_fail;
14424 temp2 = true;
14425 }
14426 if (obj2) {
14427 {
14428 arg3 = wxString_in_helper(obj2);
14429 if (arg3 == NULL) SWIG_fail;
14430 temp3 = true;
14431 }
14432 }
14433 {
14434 PyThreadState* __tstate = wxPyBeginAllowThreads();
14435 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14436
14437 wxPyEndAllowThreads(__tstate);
14438 if (PyErr_Occurred()) SWIG_fail;
14439 }
14440 resultobj = result;
14441 {
14442 if (temp2)
14443 delete arg2;
14444 }
14445 {
14446 if (temp3)
14447 delete arg3;
14448 }
14449 return resultobj;
14450 fail:
14451 {
14452 if (temp2)
14453 delete arg2;
14454 }
14455 {
14456 if (temp3)
14457 delete arg3;
14458 }
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxFileType *arg1 = (wxFileType *) 0 ;
14466 wxString *arg2 = 0 ;
14467 wxString *arg3 = 0 ;
14468 bool arg4 = (bool) true ;
14469 bool result;
14470 bool temp2 = false ;
14471 bool temp3 = false ;
14472 PyObject * obj0 = 0 ;
14473 PyObject * obj1 = 0 ;
14474 PyObject * obj2 = 0 ;
14475 PyObject * obj3 = 0 ;
14476 char *kwnames[] = {
14477 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14478 };
14479
14480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14482 if (SWIG_arg_fail(1)) SWIG_fail;
14483 {
14484 arg2 = wxString_in_helper(obj1);
14485 if (arg2 == NULL) SWIG_fail;
14486 temp2 = true;
14487 }
14488 {
14489 arg3 = wxString_in_helper(obj2);
14490 if (arg3 == NULL) SWIG_fail;
14491 temp3 = true;
14492 }
14493 if (obj3) {
14494 {
14495 arg4 = (bool)(SWIG_As_bool(obj3));
14496 if (SWIG_arg_fail(4)) SWIG_fail;
14497 }
14498 }
14499 {
14500 PyThreadState* __tstate = wxPyBeginAllowThreads();
14501 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14502
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 {
14507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14508 }
14509 {
14510 if (temp2)
14511 delete arg2;
14512 }
14513 {
14514 if (temp3)
14515 delete arg3;
14516 }
14517 return resultobj;
14518 fail:
14519 {
14520 if (temp2)
14521 delete arg2;
14522 }
14523 {
14524 if (temp3)
14525 delete arg3;
14526 }
14527 return NULL;
14528 }
14529
14530
14531 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14532 PyObject *resultobj;
14533 wxFileType *arg1 = (wxFileType *) 0 ;
14534 wxString const &arg2_defvalue = wxPyEmptyString ;
14535 wxString *arg2 = (wxString *) &arg2_defvalue ;
14536 int arg3 = (int) 0 ;
14537 bool result;
14538 bool temp2 = false ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 PyObject * obj2 = 0 ;
14542 char *kwnames[] = {
14543 (char *) "self",(char *) "cmd",(char *) "index", NULL
14544 };
14545
14546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14548 if (SWIG_arg_fail(1)) SWIG_fail;
14549 if (obj1) {
14550 {
14551 arg2 = wxString_in_helper(obj1);
14552 if (arg2 == NULL) SWIG_fail;
14553 temp2 = true;
14554 }
14555 }
14556 if (obj2) {
14557 {
14558 arg3 = (int)(SWIG_As_int(obj2));
14559 if (SWIG_arg_fail(3)) SWIG_fail;
14560 }
14561 }
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14565
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 {
14570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14571 }
14572 {
14573 if (temp2)
14574 delete arg2;
14575 }
14576 return resultobj;
14577 fail:
14578 {
14579 if (temp2)
14580 delete arg2;
14581 }
14582 return NULL;
14583 }
14584
14585
14586 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14587 PyObject *resultobj;
14588 wxFileType *arg1 = (wxFileType *) 0 ;
14589 bool result;
14590 PyObject * obj0 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (bool)(arg1)->Unassociate();
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 {
14606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14607 }
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxString *arg1 = 0 ;
14617 wxString *arg2 = 0 ;
14618 wxString const &arg3_defvalue = wxPyEmptyString ;
14619 wxString *arg3 = (wxString *) &arg3_defvalue ;
14620 wxString result;
14621 bool temp1 = false ;
14622 bool temp2 = false ;
14623 bool temp3 = false ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 PyObject * obj2 = 0 ;
14627 char *kwnames[] = {
14628 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14629 };
14630
14631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14632 {
14633 arg1 = wxString_in_helper(obj0);
14634 if (arg1 == NULL) SWIG_fail;
14635 temp1 = true;
14636 }
14637 {
14638 arg2 = wxString_in_helper(obj1);
14639 if (arg2 == NULL) SWIG_fail;
14640 temp2 = true;
14641 }
14642 if (obj2) {
14643 {
14644 arg3 = wxString_in_helper(obj2);
14645 if (arg3 == NULL) SWIG_fail;
14646 temp3 = true;
14647 }
14648 }
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14652
14653 wxPyEndAllowThreads(__tstate);
14654 if (PyErr_Occurred()) SWIG_fail;
14655 }
14656 {
14657 #if wxUSE_UNICODE
14658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14659 #else
14660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14661 #endif
14662 }
14663 {
14664 if (temp1)
14665 delete arg1;
14666 }
14667 {
14668 if (temp2)
14669 delete arg2;
14670 }
14671 {
14672 if (temp3)
14673 delete arg3;
14674 }
14675 return resultobj;
14676 fail:
14677 {
14678 if (temp1)
14679 delete arg1;
14680 }
14681 {
14682 if (temp2)
14683 delete arg2;
14684 }
14685 {
14686 if (temp3)
14687 delete arg3;
14688 }
14689 return NULL;
14690 }
14691
14692
14693 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14694 PyObject *obj;
14695 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14696 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14697 Py_INCREF(obj);
14698 return Py_BuildValue((char *)"");
14699 }
14700 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14701 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14702 return 1;
14703 }
14704
14705
14706 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14707 PyObject *pyobj;
14708
14709 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14710 return pyobj;
14711 }
14712
14713
14714 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14715 PyObject *resultobj;
14716 wxString *arg1 = 0 ;
14717 wxString *arg2 = 0 ;
14718 bool result;
14719 bool temp1 = false ;
14720 bool temp2 = false ;
14721 PyObject * obj0 = 0 ;
14722 PyObject * obj1 = 0 ;
14723 char *kwnames[] = {
14724 (char *) "mimeType",(char *) "wildcard", NULL
14725 };
14726
14727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14728 {
14729 arg1 = wxString_in_helper(obj0);
14730 if (arg1 == NULL) SWIG_fail;
14731 temp1 = true;
14732 }
14733 {
14734 arg2 = wxString_in_helper(obj1);
14735 if (arg2 == NULL) SWIG_fail;
14736 temp2 = true;
14737 }
14738 {
14739 PyThreadState* __tstate = wxPyBeginAllowThreads();
14740 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14741
14742 wxPyEndAllowThreads(__tstate);
14743 if (PyErr_Occurred()) SWIG_fail;
14744 }
14745 {
14746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14747 }
14748 {
14749 if (temp1)
14750 delete arg1;
14751 }
14752 {
14753 if (temp2)
14754 delete arg2;
14755 }
14756 return resultobj;
14757 fail:
14758 {
14759 if (temp1)
14760 delete arg1;
14761 }
14762 {
14763 if (temp2)
14764 delete arg2;
14765 }
14766 return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxMimeTypesManager *result;
14773 char *kwnames[] = {
14774 NULL
14775 };
14776
14777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14793 PyObject *resultobj;
14794 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14795 int arg2 = (int) wxMAILCAP_ALL ;
14796 wxString const &arg3_defvalue = wxPyEmptyString ;
14797 wxString *arg3 = (wxString *) &arg3_defvalue ;
14798 bool temp3 = false ;
14799 PyObject * obj0 = 0 ;
14800 PyObject * obj1 = 0 ;
14801 PyObject * obj2 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 if (obj1) {
14810 {
14811 arg2 = (int)(SWIG_As_int(obj1));
14812 if (SWIG_arg_fail(2)) SWIG_fail;
14813 }
14814 }
14815 if (obj2) {
14816 {
14817 arg3 = wxString_in_helper(obj2);
14818 if (arg3 == NULL) SWIG_fail;
14819 temp3 = true;
14820 }
14821 }
14822 {
14823 PyThreadState* __tstate = wxPyBeginAllowThreads();
14824 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14825
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 Py_INCREF(Py_None); resultobj = Py_None;
14830 {
14831 if (temp3)
14832 delete arg3;
14833 }
14834 return resultobj;
14835 fail:
14836 {
14837 if (temp3)
14838 delete arg3;
14839 }
14840 return NULL;
14841 }
14842
14843
14844 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14845 PyObject *resultobj;
14846 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14847 PyObject * obj0 = 0 ;
14848 char *kwnames[] = {
14849 (char *) "self", NULL
14850 };
14851
14852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14854 if (SWIG_arg_fail(1)) SWIG_fail;
14855 {
14856 PyThreadState* __tstate = wxPyBeginAllowThreads();
14857 (arg1)->ClearData();
14858
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 Py_INCREF(Py_None); resultobj = Py_None;
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj;
14871 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14872 wxString *arg2 = 0 ;
14873 wxFileType *result;
14874 bool temp2 = false ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 char *kwnames[] = {
14878 (char *) "self",(char *) "ext", NULL
14879 };
14880
14881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14883 if (SWIG_arg_fail(1)) SWIG_fail;
14884 {
14885 arg2 = wxString_in_helper(obj1);
14886 if (arg2 == NULL) SWIG_fail;
14887 temp2 = true;
14888 }
14889 {
14890 PyThreadState* __tstate = wxPyBeginAllowThreads();
14891 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14892
14893 wxPyEndAllowThreads(__tstate);
14894 if (PyErr_Occurred()) SWIG_fail;
14895 }
14896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14897 {
14898 if (temp2)
14899 delete arg2;
14900 }
14901 return resultobj;
14902 fail:
14903 {
14904 if (temp2)
14905 delete arg2;
14906 }
14907 return NULL;
14908 }
14909
14910
14911 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14912 PyObject *resultobj;
14913 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14914 wxString *arg2 = 0 ;
14915 wxFileType *result;
14916 bool temp2 = false ;
14917 PyObject * obj0 = 0 ;
14918 PyObject * obj1 = 0 ;
14919 char *kwnames[] = {
14920 (char *) "self",(char *) "mimeType", NULL
14921 };
14922
14923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14925 if (SWIG_arg_fail(1)) SWIG_fail;
14926 {
14927 arg2 = wxString_in_helper(obj1);
14928 if (arg2 == NULL) SWIG_fail;
14929 temp2 = true;
14930 }
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14934
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14939 {
14940 if (temp2)
14941 delete arg2;
14942 }
14943 return resultobj;
14944 fail:
14945 {
14946 if (temp2)
14947 delete arg2;
14948 }
14949 return NULL;
14950 }
14951
14952
14953 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj;
14955 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14956 wxString *arg2 = 0 ;
14957 bool arg3 = (bool) false ;
14958 bool result;
14959 bool temp2 = false ;
14960 PyObject * obj0 = 0 ;
14961 PyObject * obj1 = 0 ;
14962 PyObject * obj2 = 0 ;
14963 char *kwnames[] = {
14964 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14969 if (SWIG_arg_fail(1)) SWIG_fail;
14970 {
14971 arg2 = wxString_in_helper(obj1);
14972 if (arg2 == NULL) SWIG_fail;
14973 temp2 = true;
14974 }
14975 if (obj2) {
14976 {
14977 arg3 = (bool)(SWIG_As_bool(obj2));
14978 if (SWIG_arg_fail(3)) SWIG_fail;
14979 }
14980 }
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14990 }
14991 {
14992 if (temp2)
14993 delete arg2;
14994 }
14995 return resultobj;
14996 fail:
14997 {
14998 if (temp2)
14999 delete arg2;
15000 }
15001 return NULL;
15002 }
15003
15004
15005 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15006 PyObject *resultobj;
15007 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15008 wxString *arg2 = 0 ;
15009 bool result;
15010 bool temp2 = false ;
15011 PyObject * obj0 = 0 ;
15012 PyObject * obj1 = 0 ;
15013 char *kwnames[] = {
15014 (char *) "self",(char *) "filename", NULL
15015 };
15016
15017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15019 if (SWIG_arg_fail(1)) SWIG_fail;
15020 {
15021 arg2 = wxString_in_helper(obj1);
15022 if (arg2 == NULL) SWIG_fail;
15023 temp2 = true;
15024 }
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15028
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 {
15033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15034 }
15035 {
15036 if (temp2)
15037 delete arg2;
15038 }
15039 return resultobj;
15040 fail:
15041 {
15042 if (temp2)
15043 delete arg2;
15044 }
15045 return NULL;
15046 }
15047
15048
15049 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15050 PyObject *resultobj;
15051 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15052 PyObject *result;
15053 PyObject * obj0 = 0 ;
15054 char *kwnames[] = {
15055 (char *) "self", NULL
15056 };
15057
15058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15060 if (SWIG_arg_fail(1)) SWIG_fail;
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15064
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 resultobj = result;
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15076 PyObject *resultobj;
15077 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15078 wxFileTypeInfo *arg2 = 0 ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 char *kwnames[] = {
15082 (char *) "self",(char *) "ft", NULL
15083 };
15084
15085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15087 if (SWIG_arg_fail(1)) SWIG_fail;
15088 {
15089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15090 if (SWIG_arg_fail(2)) SWIG_fail;
15091 if (arg2 == NULL) {
15092 SWIG_null_ref("wxFileTypeInfo");
15093 }
15094 if (SWIG_arg_fail(2)) SWIG_fail;
15095 }
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15099
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 Py_INCREF(Py_None); resultobj = Py_None;
15104 return resultobj;
15105 fail:
15106 return NULL;
15107 }
15108
15109
15110 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15111 PyObject *resultobj;
15112 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15113 wxFileTypeInfo *arg2 = 0 ;
15114 wxFileType *result;
15115 PyObject * obj0 = 0 ;
15116 PyObject * obj1 = 0 ;
15117 char *kwnames[] = {
15118 (char *) "self",(char *) "ftInfo", NULL
15119 };
15120
15121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15123 if (SWIG_arg_fail(1)) SWIG_fail;
15124 {
15125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15126 if (SWIG_arg_fail(2)) SWIG_fail;
15127 if (arg2 == NULL) {
15128 SWIG_null_ref("wxFileTypeInfo");
15129 }
15130 if (SWIG_arg_fail(2)) SWIG_fail;
15131 }
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15140 return resultobj;
15141 fail:
15142 return NULL;
15143 }
15144
15145
15146 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15147 PyObject *resultobj;
15148 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15149 wxFileType *arg2 = (wxFileType *) 0 ;
15150 bool result;
15151 PyObject * obj0 = 0 ;
15152 PyObject * obj1 = 0 ;
15153 char *kwnames[] = {
15154 (char *) "self",(char *) "ft", NULL
15155 };
15156
15157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15159 if (SWIG_arg_fail(1)) SWIG_fail;
15160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15161 if (SWIG_arg_fail(2)) SWIG_fail;
15162 {
15163 PyThreadState* __tstate = wxPyBeginAllowThreads();
15164 result = (bool)(arg1)->Unassociate(arg2);
15165
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 {
15170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15171 }
15172 return resultobj;
15173 fail:
15174 return NULL;
15175 }
15176
15177
15178 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15179 PyObject *resultobj;
15180 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15181 PyObject * obj0 = 0 ;
15182 char *kwnames[] = {
15183 (char *) "self", NULL
15184 };
15185
15186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15188 if (SWIG_arg_fail(1)) SWIG_fail;
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 delete arg1;
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 Py_INCREF(Py_None); resultobj = Py_None;
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15204 PyObject *obj;
15205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15206 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15207 Py_INCREF(obj);
15208 return Py_BuildValue((char *)"");
15209 }
15210 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15211 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15212 return 1;
15213 }
15214
15215
15216 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15217 PyObject *pyobj;
15218
15219 {
15220 #if wxUSE_UNICODE
15221 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15222 #else
15223 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15224 #endif
15225 }
15226 return pyobj;
15227 }
15228
15229
15230 static int _wrap_ART_MENU_set(PyObject *) {
15231 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15232 return 1;
15233 }
15234
15235
15236 static PyObject *_wrap_ART_MENU_get(void) {
15237 PyObject *pyobj;
15238
15239 {
15240 #if wxUSE_UNICODE
15241 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15242 #else
15243 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15244 #endif
15245 }
15246 return pyobj;
15247 }
15248
15249
15250 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15251 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15252 return 1;
15253 }
15254
15255
15256 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15257 PyObject *pyobj;
15258
15259 {
15260 #if wxUSE_UNICODE
15261 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15262 #else
15263 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15264 #endif
15265 }
15266 return pyobj;
15267 }
15268
15269
15270 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15271 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15272 return 1;
15273 }
15274
15275
15276 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15277 PyObject *pyobj;
15278
15279 {
15280 #if wxUSE_UNICODE
15281 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15282 #else
15283 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15284 #endif
15285 }
15286 return pyobj;
15287 }
15288
15289
15290 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15291 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15292 return 1;
15293 }
15294
15295
15296 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15297 PyObject *pyobj;
15298
15299 {
15300 #if wxUSE_UNICODE
15301 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15302 #else
15303 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15304 #endif
15305 }
15306 return pyobj;
15307 }
15308
15309
15310 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15311 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15312 return 1;
15313 }
15314
15315
15316 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15317 PyObject *pyobj;
15318
15319 {
15320 #if wxUSE_UNICODE
15321 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15322 #else
15323 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15324 #endif
15325 }
15326 return pyobj;
15327 }
15328
15329
15330 static int _wrap_ART_BUTTON_set(PyObject *) {
15331 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15332 return 1;
15333 }
15334
15335
15336 static PyObject *_wrap_ART_BUTTON_get(void) {
15337 PyObject *pyobj;
15338
15339 {
15340 #if wxUSE_UNICODE
15341 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15342 #else
15343 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15344 #endif
15345 }
15346 return pyobj;
15347 }
15348
15349
15350 static int _wrap_ART_OTHER_set(PyObject *) {
15351 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15352 return 1;
15353 }
15354
15355
15356 static PyObject *_wrap_ART_OTHER_get(void) {
15357 PyObject *pyobj;
15358
15359 {
15360 #if wxUSE_UNICODE
15361 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15362 #else
15363 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15364 #endif
15365 }
15366 return pyobj;
15367 }
15368
15369
15370 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15371 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15372 return 1;
15373 }
15374
15375
15376 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15377 PyObject *pyobj;
15378
15379 {
15380 #if wxUSE_UNICODE
15381 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15382 #else
15383 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15384 #endif
15385 }
15386 return pyobj;
15387 }
15388
15389
15390 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15391 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15392 return 1;
15393 }
15394
15395
15396 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15397 PyObject *pyobj;
15398
15399 {
15400 #if wxUSE_UNICODE
15401 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15402 #else
15403 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15404 #endif
15405 }
15406 return pyobj;
15407 }
15408
15409
15410 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15411 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15412 return 1;
15413 }
15414
15415
15416 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15417 PyObject *pyobj;
15418
15419 {
15420 #if wxUSE_UNICODE
15421 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15422 #else
15423 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15424 #endif
15425 }
15426 return pyobj;
15427 }
15428
15429
15430 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15431 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15432 return 1;
15433 }
15434
15435
15436 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15437 PyObject *pyobj;
15438
15439 {
15440 #if wxUSE_UNICODE
15441 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15442 #else
15443 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15444 #endif
15445 }
15446 return pyobj;
15447 }
15448
15449
15450 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15451 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15452 return 1;
15453 }
15454
15455
15456 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15457 PyObject *pyobj;
15458
15459 {
15460 #if wxUSE_UNICODE
15461 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15462 #else
15463 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15464 #endif
15465 }
15466 return pyobj;
15467 }
15468
15469
15470 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15471 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15472 return 1;
15473 }
15474
15475
15476 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15477 PyObject *pyobj;
15478
15479 {
15480 #if wxUSE_UNICODE
15481 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15482 #else
15483 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15484 #endif
15485 }
15486 return pyobj;
15487 }
15488
15489
15490 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15491 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15492 return 1;
15493 }
15494
15495
15496 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15497 PyObject *pyobj;
15498
15499 {
15500 #if wxUSE_UNICODE
15501 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15502 #else
15503 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15504 #endif
15505 }
15506 return pyobj;
15507 }
15508
15509
15510 static int _wrap_ART_GO_BACK_set(PyObject *) {
15511 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15512 return 1;
15513 }
15514
15515
15516 static PyObject *_wrap_ART_GO_BACK_get(void) {
15517 PyObject *pyobj;
15518
15519 {
15520 #if wxUSE_UNICODE
15521 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15522 #else
15523 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15524 #endif
15525 }
15526 return pyobj;
15527 }
15528
15529
15530 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15531 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15532 return 1;
15533 }
15534
15535
15536 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15537 PyObject *pyobj;
15538
15539 {
15540 #if wxUSE_UNICODE
15541 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15542 #else
15543 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15544 #endif
15545 }
15546 return pyobj;
15547 }
15548
15549
15550 static int _wrap_ART_GO_UP_set(PyObject *) {
15551 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15552 return 1;
15553 }
15554
15555
15556 static PyObject *_wrap_ART_GO_UP_get(void) {
15557 PyObject *pyobj;
15558
15559 {
15560 #if wxUSE_UNICODE
15561 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15562 #else
15563 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15564 #endif
15565 }
15566 return pyobj;
15567 }
15568
15569
15570 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15571 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15572 return 1;
15573 }
15574
15575
15576 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15577 PyObject *pyobj;
15578
15579 {
15580 #if wxUSE_UNICODE
15581 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15582 #else
15583 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15584 #endif
15585 }
15586 return pyobj;
15587 }
15588
15589
15590 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15591 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15592 return 1;
15593 }
15594
15595
15596 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15597 PyObject *pyobj;
15598
15599 {
15600 #if wxUSE_UNICODE
15601 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15602 #else
15603 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15604 #endif
15605 }
15606 return pyobj;
15607 }
15608
15609
15610 static int _wrap_ART_GO_HOME_set(PyObject *) {
15611 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15612 return 1;
15613 }
15614
15615
15616 static PyObject *_wrap_ART_GO_HOME_get(void) {
15617 PyObject *pyobj;
15618
15619 {
15620 #if wxUSE_UNICODE
15621 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15622 #else
15623 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15624 #endif
15625 }
15626 return pyobj;
15627 }
15628
15629
15630 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15631 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15632 return 1;
15633 }
15634
15635
15636 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15637 PyObject *pyobj;
15638
15639 {
15640 #if wxUSE_UNICODE
15641 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15642 #else
15643 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15644 #endif
15645 }
15646 return pyobj;
15647 }
15648
15649
15650 static int _wrap_ART_PRINT_set(PyObject *) {
15651 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15652 return 1;
15653 }
15654
15655
15656 static PyObject *_wrap_ART_PRINT_get(void) {
15657 PyObject *pyobj;
15658
15659 {
15660 #if wxUSE_UNICODE
15661 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15662 #else
15663 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15664 #endif
15665 }
15666 return pyobj;
15667 }
15668
15669
15670 static int _wrap_ART_HELP_set(PyObject *) {
15671 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15672 return 1;
15673 }
15674
15675
15676 static PyObject *_wrap_ART_HELP_get(void) {
15677 PyObject *pyobj;
15678
15679 {
15680 #if wxUSE_UNICODE
15681 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15682 #else
15683 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15684 #endif
15685 }
15686 return pyobj;
15687 }
15688
15689
15690 static int _wrap_ART_TIP_set(PyObject *) {
15691 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15692 return 1;
15693 }
15694
15695
15696 static PyObject *_wrap_ART_TIP_get(void) {
15697 PyObject *pyobj;
15698
15699 {
15700 #if wxUSE_UNICODE
15701 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15702 #else
15703 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15704 #endif
15705 }
15706 return pyobj;
15707 }
15708
15709
15710 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15711 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15712 return 1;
15713 }
15714
15715
15716 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15717 PyObject *pyobj;
15718
15719 {
15720 #if wxUSE_UNICODE
15721 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15722 #else
15723 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15724 #endif
15725 }
15726 return pyobj;
15727 }
15728
15729
15730 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15731 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15732 return 1;
15733 }
15734
15735
15736 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15737 PyObject *pyobj;
15738
15739 {
15740 #if wxUSE_UNICODE
15741 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15742 #else
15743 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15744 #endif
15745 }
15746 return pyobj;
15747 }
15748
15749
15750 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15751 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15752 return 1;
15753 }
15754
15755
15756 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15757 PyObject *pyobj;
15758
15759 {
15760 #if wxUSE_UNICODE
15761 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15762 #else
15763 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15764 #endif
15765 }
15766 return pyobj;
15767 }
15768
15769
15770 static int _wrap_ART_HARDDISK_set(PyObject *) {
15771 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15772 return 1;
15773 }
15774
15775
15776 static PyObject *_wrap_ART_HARDDISK_get(void) {
15777 PyObject *pyobj;
15778
15779 {
15780 #if wxUSE_UNICODE
15781 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15782 #else
15783 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15784 #endif
15785 }
15786 return pyobj;
15787 }
15788
15789
15790 static int _wrap_ART_FLOPPY_set(PyObject *) {
15791 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15792 return 1;
15793 }
15794
15795
15796 static PyObject *_wrap_ART_FLOPPY_get(void) {
15797 PyObject *pyobj;
15798
15799 {
15800 #if wxUSE_UNICODE
15801 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15802 #else
15803 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15804 #endif
15805 }
15806 return pyobj;
15807 }
15808
15809
15810 static int _wrap_ART_CDROM_set(PyObject *) {
15811 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15812 return 1;
15813 }
15814
15815
15816 static PyObject *_wrap_ART_CDROM_get(void) {
15817 PyObject *pyobj;
15818
15819 {
15820 #if wxUSE_UNICODE
15821 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15822 #else
15823 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15824 #endif
15825 }
15826 return pyobj;
15827 }
15828
15829
15830 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15831 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15832 return 1;
15833 }
15834
15835
15836 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15837 PyObject *pyobj;
15838
15839 {
15840 #if wxUSE_UNICODE
15841 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15842 #else
15843 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15844 #endif
15845 }
15846 return pyobj;
15847 }
15848
15849
15850 static int _wrap_ART_FOLDER_set(PyObject *) {
15851 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15852 return 1;
15853 }
15854
15855
15856 static PyObject *_wrap_ART_FOLDER_get(void) {
15857 PyObject *pyobj;
15858
15859 {
15860 #if wxUSE_UNICODE
15861 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15862 #else
15863 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15864 #endif
15865 }
15866 return pyobj;
15867 }
15868
15869
15870 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15871 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15872 return 1;
15873 }
15874
15875
15876 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15877 PyObject *pyobj;
15878
15879 {
15880 #if wxUSE_UNICODE
15881 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15882 #else
15883 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15884 #endif
15885 }
15886 return pyobj;
15887 }
15888
15889
15890 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15891 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15892 return 1;
15893 }
15894
15895
15896 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15897 PyObject *pyobj;
15898
15899 {
15900 #if wxUSE_UNICODE
15901 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15902 #else
15903 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15904 #endif
15905 }
15906 return pyobj;
15907 }
15908
15909
15910 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15911 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15912 return 1;
15913 }
15914
15915
15916 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15917 PyObject *pyobj;
15918
15919 {
15920 #if wxUSE_UNICODE
15921 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15922 #else
15923 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15924 #endif
15925 }
15926 return pyobj;
15927 }
15928
15929
15930 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15931 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15932 return 1;
15933 }
15934
15935
15936 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15937 PyObject *pyobj;
15938
15939 {
15940 #if wxUSE_UNICODE
15941 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15942 #else
15943 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15944 #endif
15945 }
15946 return pyobj;
15947 }
15948
15949
15950 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15951 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15952 return 1;
15953 }
15954
15955
15956 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15957 PyObject *pyobj;
15958
15959 {
15960 #if wxUSE_UNICODE
15961 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15962 #else
15963 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15964 #endif
15965 }
15966 return pyobj;
15967 }
15968
15969
15970 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15971 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15972 return 1;
15973 }
15974
15975
15976 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15977 PyObject *pyobj;
15978
15979 {
15980 #if wxUSE_UNICODE
15981 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15982 #else
15983 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15984 #endif
15985 }
15986 return pyobj;
15987 }
15988
15989
15990 static int _wrap_ART_ERROR_set(PyObject *) {
15991 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
15992 return 1;
15993 }
15994
15995
15996 static PyObject *_wrap_ART_ERROR_get(void) {
15997 PyObject *pyobj;
15998
15999 {
16000 #if wxUSE_UNICODE
16001 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16002 #else
16003 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16004 #endif
16005 }
16006 return pyobj;
16007 }
16008
16009
16010 static int _wrap_ART_QUESTION_set(PyObject *) {
16011 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16012 return 1;
16013 }
16014
16015
16016 static PyObject *_wrap_ART_QUESTION_get(void) {
16017 PyObject *pyobj;
16018
16019 {
16020 #if wxUSE_UNICODE
16021 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16022 #else
16023 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16024 #endif
16025 }
16026 return pyobj;
16027 }
16028
16029
16030 static int _wrap_ART_WARNING_set(PyObject *) {
16031 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16032 return 1;
16033 }
16034
16035
16036 static PyObject *_wrap_ART_WARNING_get(void) {
16037 PyObject *pyobj;
16038
16039 {
16040 #if wxUSE_UNICODE
16041 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16042 #else
16043 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16044 #endif
16045 }
16046 return pyobj;
16047 }
16048
16049
16050 static int _wrap_ART_INFORMATION_set(PyObject *) {
16051 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16052 return 1;
16053 }
16054
16055
16056 static PyObject *_wrap_ART_INFORMATION_get(void) {
16057 PyObject *pyobj;
16058
16059 {
16060 #if wxUSE_UNICODE
16061 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16062 #else
16063 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16064 #endif
16065 }
16066 return pyobj;
16067 }
16068
16069
16070 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16071 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16072 return 1;
16073 }
16074
16075
16076 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16077 PyObject *pyobj;
16078
16079 {
16080 #if wxUSE_UNICODE
16081 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16082 #else
16083 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16084 #endif
16085 }
16086 return pyobj;
16087 }
16088
16089
16090 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16091 PyObject *resultobj;
16092 wxPyArtProvider *result;
16093 char *kwnames[] = {
16094 NULL
16095 };
16096
16097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16098 {
16099 if (!wxPyCheckForApp()) SWIG_fail;
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (wxPyArtProvider *)new wxPyArtProvider();
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj;
16115 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16116 PyObject *arg2 = (PyObject *) 0 ;
16117 PyObject *arg3 = (PyObject *) 0 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 PyObject * obj2 = 0 ;
16121 char *kwnames[] = {
16122 (char *) "self",(char *) "self",(char *) "_class", NULL
16123 };
16124
16125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16127 if (SWIG_arg_fail(1)) SWIG_fail;
16128 arg2 = obj1;
16129 arg3 = obj2;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 (arg1)->_setCallbackInfo(arg2,arg3);
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 Py_INCREF(Py_None); resultobj = Py_None;
16138 return resultobj;
16139 fail:
16140 return NULL;
16141 }
16142
16143
16144 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj;
16146 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16147 PyObject * obj0 = 0 ;
16148 char *kwnames[] = {
16149 (char *) "provider", NULL
16150 };
16151
16152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16154 if (SWIG_arg_fail(1)) SWIG_fail;
16155 {
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 wxPyArtProvider::PushProvider(arg1);
16158
16159 wxPyEndAllowThreads(__tstate);
16160 if (PyErr_Occurred()) SWIG_fail;
16161 }
16162 Py_INCREF(Py_None); resultobj = Py_None;
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj;
16171 bool result;
16172 char *kwnames[] = {
16173 NULL
16174 };
16175
16176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16177 {
16178 PyThreadState* __tstate = wxPyBeginAllowThreads();
16179 result = (bool)wxPyArtProvider::PopProvider();
16180
16181 wxPyEndAllowThreads(__tstate);
16182 if (PyErr_Occurred()) SWIG_fail;
16183 }
16184 {
16185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16186 }
16187 return resultobj;
16188 fail:
16189 return NULL;
16190 }
16191
16192
16193 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16194 PyObject *resultobj;
16195 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16196 bool result;
16197 PyObject * obj0 = 0 ;
16198 char *kwnames[] = {
16199 (char *) "provider", NULL
16200 };
16201
16202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16204 if (SWIG_arg_fail(1)) SWIG_fail;
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16208
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 {
16213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16214 }
16215 return resultobj;
16216 fail:
16217 return NULL;
16218 }
16219
16220
16221 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16222 PyObject *resultobj;
16223 wxString *arg1 = 0 ;
16224 wxString const &arg2_defvalue = wxPyART_OTHER ;
16225 wxString *arg2 = (wxString *) &arg2_defvalue ;
16226 wxSize const &arg3_defvalue = wxDefaultSize ;
16227 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16228 wxBitmap result;
16229 bool temp1 = false ;
16230 bool temp2 = false ;
16231 wxSize temp3 ;
16232 PyObject * obj0 = 0 ;
16233 PyObject * obj1 = 0 ;
16234 PyObject * obj2 = 0 ;
16235 char *kwnames[] = {
16236 (char *) "id",(char *) "client",(char *) "size", NULL
16237 };
16238
16239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16240 {
16241 arg1 = wxString_in_helper(obj0);
16242 if (arg1 == NULL) SWIG_fail;
16243 temp1 = true;
16244 }
16245 if (obj1) {
16246 {
16247 arg2 = wxString_in_helper(obj1);
16248 if (arg2 == NULL) SWIG_fail;
16249 temp2 = true;
16250 }
16251 }
16252 if (obj2) {
16253 {
16254 arg3 = &temp3;
16255 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16256 }
16257 }
16258 {
16259 if (!wxPyCheckForApp()) SWIG_fail;
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16262
16263 wxPyEndAllowThreads(__tstate);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 }
16266 {
16267 wxBitmap * resultptr;
16268 resultptr = new wxBitmap((wxBitmap &)(result));
16269 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16270 }
16271 {
16272 if (temp1)
16273 delete arg1;
16274 }
16275 {
16276 if (temp2)
16277 delete arg2;
16278 }
16279 return resultobj;
16280 fail:
16281 {
16282 if (temp1)
16283 delete arg1;
16284 }
16285 {
16286 if (temp2)
16287 delete arg2;
16288 }
16289 return NULL;
16290 }
16291
16292
16293 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16294 PyObject *resultobj;
16295 wxString *arg1 = 0 ;
16296 wxString const &arg2_defvalue = wxPyART_OTHER ;
16297 wxString *arg2 = (wxString *) &arg2_defvalue ;
16298 wxSize const &arg3_defvalue = wxDefaultSize ;
16299 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16300 wxIcon result;
16301 bool temp1 = false ;
16302 bool temp2 = false ;
16303 wxSize temp3 ;
16304 PyObject * obj0 = 0 ;
16305 PyObject * obj1 = 0 ;
16306 PyObject * obj2 = 0 ;
16307 char *kwnames[] = {
16308 (char *) "id",(char *) "client",(char *) "size", NULL
16309 };
16310
16311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16312 {
16313 arg1 = wxString_in_helper(obj0);
16314 if (arg1 == NULL) SWIG_fail;
16315 temp1 = true;
16316 }
16317 if (obj1) {
16318 {
16319 arg2 = wxString_in_helper(obj1);
16320 if (arg2 == NULL) SWIG_fail;
16321 temp2 = true;
16322 }
16323 }
16324 if (obj2) {
16325 {
16326 arg3 = &temp3;
16327 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16328 }
16329 }
16330 {
16331 if (!wxPyCheckForApp()) SWIG_fail;
16332 PyThreadState* __tstate = wxPyBeginAllowThreads();
16333 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16334
16335 wxPyEndAllowThreads(__tstate);
16336 if (PyErr_Occurred()) SWIG_fail;
16337 }
16338 {
16339 wxIcon * resultptr;
16340 resultptr = new wxIcon((wxIcon &)(result));
16341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16342 }
16343 {
16344 if (temp1)
16345 delete arg1;
16346 }
16347 {
16348 if (temp2)
16349 delete arg2;
16350 }
16351 return resultobj;
16352 fail:
16353 {
16354 if (temp1)
16355 delete arg1;
16356 }
16357 {
16358 if (temp2)
16359 delete arg2;
16360 }
16361 return NULL;
16362 }
16363
16364
16365 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16366 PyObject *resultobj;
16367 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16368 PyObject * obj0 = 0 ;
16369 char *kwnames[] = {
16370 (char *) "self", NULL
16371 };
16372
16373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16375 if (SWIG_arg_fail(1)) SWIG_fail;
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 wxPyArtProvider_Destroy(arg1);
16379
16380 wxPyEndAllowThreads(__tstate);
16381 if (PyErr_Occurred()) SWIG_fail;
16382 }
16383 Py_INCREF(Py_None); resultobj = Py_None;
16384 return resultobj;
16385 fail:
16386 return NULL;
16387 }
16388
16389
16390 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16391 PyObject *obj;
16392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16393 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16394 Py_INCREF(obj);
16395 return Py_BuildValue((char *)"");
16396 }
16397 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16400 PyObject * obj0 = 0 ;
16401 char *kwnames[] = {
16402 (char *) "self", NULL
16403 };
16404
16405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16407 if (SWIG_arg_fail(1)) SWIG_fail;
16408 {
16409 PyThreadState* __tstate = wxPyBeginAllowThreads();
16410 delete arg1;
16411
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 Py_INCREF(Py_None); resultobj = Py_None;
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16423 PyObject *resultobj;
16424 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16425 wxConfigBase *result;
16426 PyObject * obj0 = 0 ;
16427 char *kwnames[] = {
16428 (char *) "config", NULL
16429 };
16430
16431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16433 if (SWIG_arg_fail(1)) SWIG_fail;
16434 {
16435 PyThreadState* __tstate = wxPyBeginAllowThreads();
16436 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16437
16438 wxPyEndAllowThreads(__tstate);
16439 if (PyErr_Occurred()) SWIG_fail;
16440 }
16441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16442 return resultobj;
16443 fail:
16444 return NULL;
16445 }
16446
16447
16448 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16449 PyObject *resultobj;
16450 bool arg1 = (bool) true ;
16451 wxConfigBase *result;
16452 PyObject * obj0 = 0 ;
16453 char *kwnames[] = {
16454 (char *) "createOnDemand", NULL
16455 };
16456
16457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16458 if (obj0) {
16459 {
16460 arg1 = (bool)(SWIG_As_bool(obj0));
16461 if (SWIG_arg_fail(1)) SWIG_fail;
16462 }
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16467
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16479 PyObject *resultobj;
16480 wxConfigBase *result;
16481 char *kwnames[] = {
16482 NULL
16483 };
16484
16485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16486 {
16487 PyThreadState* __tstate = wxPyBeginAllowThreads();
16488 result = (wxConfigBase *)wxConfigBase::Create();
16489
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16501 PyObject *resultobj;
16502 char *kwnames[] = {
16503 NULL
16504 };
16505
16506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16507 {
16508 PyThreadState* __tstate = wxPyBeginAllowThreads();
16509 wxConfigBase::DontCreateOnDemand();
16510
16511 wxPyEndAllowThreads(__tstate);
16512 if (PyErr_Occurred()) SWIG_fail;
16513 }
16514 Py_INCREF(Py_None); resultobj = Py_None;
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj;
16523 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16524 wxString *arg2 = 0 ;
16525 bool temp2 = false ;
16526 PyObject * obj0 = 0 ;
16527 PyObject * obj1 = 0 ;
16528 char *kwnames[] = {
16529 (char *) "self",(char *) "path", NULL
16530 };
16531
16532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16534 if (SWIG_arg_fail(1)) SWIG_fail;
16535 {
16536 arg2 = wxString_in_helper(obj1);
16537 if (arg2 == NULL) SWIG_fail;
16538 temp2 = true;
16539 }
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 (arg1)->SetPath((wxString const &)*arg2);
16543
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 Py_INCREF(Py_None); resultobj = Py_None;
16548 {
16549 if (temp2)
16550 delete arg2;
16551 }
16552 return resultobj;
16553 fail:
16554 {
16555 if (temp2)
16556 delete arg2;
16557 }
16558 return NULL;
16559 }
16560
16561
16562 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16563 PyObject *resultobj;
16564 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16565 wxString *result;
16566 PyObject * obj0 = 0 ;
16567 char *kwnames[] = {
16568 (char *) "self", NULL
16569 };
16570
16571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16573 if (SWIG_arg_fail(1)) SWIG_fail;
16574 {
16575 PyThreadState* __tstate = wxPyBeginAllowThreads();
16576 {
16577 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16578 result = (wxString *) &_result_ref;
16579 }
16580
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 {
16585 #if wxUSE_UNICODE
16586 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16587 #else
16588 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16589 #endif
16590 }
16591 return resultobj;
16592 fail:
16593 return NULL;
16594 }
16595
16596
16597 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj;
16599 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16600 PyObject *result;
16601 PyObject * obj0 = 0 ;
16602 char *kwnames[] = {
16603 (char *) "self", NULL
16604 };
16605
16606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16608 if (SWIG_arg_fail(1)) SWIG_fail;
16609 {
16610 PyThreadState* __tstate = wxPyBeginAllowThreads();
16611 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16612
16613 wxPyEndAllowThreads(__tstate);
16614 if (PyErr_Occurred()) SWIG_fail;
16615 }
16616 resultobj = result;
16617 return resultobj;
16618 fail:
16619 return NULL;
16620 }
16621
16622
16623 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16624 PyObject *resultobj;
16625 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16626 long arg2 ;
16627 PyObject *result;
16628 PyObject * obj0 = 0 ;
16629 PyObject * obj1 = 0 ;
16630 char *kwnames[] = {
16631 (char *) "self",(char *) "index", NULL
16632 };
16633
16634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16636 if (SWIG_arg_fail(1)) SWIG_fail;
16637 {
16638 arg2 = (long)(SWIG_As_long(obj1));
16639 if (SWIG_arg_fail(2)) SWIG_fail;
16640 }
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16644
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 resultobj = result;
16649 return resultobj;
16650 fail:
16651 return NULL;
16652 }
16653
16654
16655 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16656 PyObject *resultobj;
16657 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16658 PyObject *result;
16659 PyObject * obj0 = 0 ;
16660 char *kwnames[] = {
16661 (char *) "self", NULL
16662 };
16663
16664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16666 if (SWIG_arg_fail(1)) SWIG_fail;
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16670
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 resultobj = result;
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16682 PyObject *resultobj;
16683 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16684 long arg2 ;
16685 PyObject *result;
16686 PyObject * obj0 = 0 ;
16687 PyObject * obj1 = 0 ;
16688 char *kwnames[] = {
16689 (char *) "self",(char *) "index", NULL
16690 };
16691
16692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16694 if (SWIG_arg_fail(1)) SWIG_fail;
16695 {
16696 arg2 = (long)(SWIG_As_long(obj1));
16697 if (SWIG_arg_fail(2)) SWIG_fail;
16698 }
16699 {
16700 PyThreadState* __tstate = wxPyBeginAllowThreads();
16701 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16702
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 resultobj = result;
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16714 PyObject *resultobj;
16715 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16716 bool arg2 = (bool) false ;
16717 size_t result;
16718 PyObject * obj0 = 0 ;
16719 PyObject * obj1 = 0 ;
16720 char *kwnames[] = {
16721 (char *) "self",(char *) "recursive", NULL
16722 };
16723
16724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16726 if (SWIG_arg_fail(1)) SWIG_fail;
16727 if (obj1) {
16728 {
16729 arg2 = (bool)(SWIG_As_bool(obj1));
16730 if (SWIG_arg_fail(2)) SWIG_fail;
16731 }
16732 }
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16736
16737 wxPyEndAllowThreads(__tstate);
16738 if (PyErr_Occurred()) SWIG_fail;
16739 }
16740 {
16741 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16742 }
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16752 bool arg2 = (bool) false ;
16753 size_t result;
16754 PyObject * obj0 = 0 ;
16755 PyObject * obj1 = 0 ;
16756 char *kwnames[] = {
16757 (char *) "self",(char *) "recursive", NULL
16758 };
16759
16760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16762 if (SWIG_arg_fail(1)) SWIG_fail;
16763 if (obj1) {
16764 {
16765 arg2 = (bool)(SWIG_As_bool(obj1));
16766 if (SWIG_arg_fail(2)) SWIG_fail;
16767 }
16768 }
16769 {
16770 PyThreadState* __tstate = wxPyBeginAllowThreads();
16771 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16772
16773 wxPyEndAllowThreads(__tstate);
16774 if (PyErr_Occurred()) SWIG_fail;
16775 }
16776 {
16777 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16778 }
16779 return resultobj;
16780 fail:
16781 return NULL;
16782 }
16783
16784
16785 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16786 PyObject *resultobj;
16787 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16788 wxString *arg2 = 0 ;
16789 bool result;
16790 bool temp2 = false ;
16791 PyObject * obj0 = 0 ;
16792 PyObject * obj1 = 0 ;
16793 char *kwnames[] = {
16794 (char *) "self",(char *) "name", NULL
16795 };
16796
16797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16799 if (SWIG_arg_fail(1)) SWIG_fail;
16800 {
16801 arg2 = wxString_in_helper(obj1);
16802 if (arg2 == NULL) SWIG_fail;
16803 temp2 = true;
16804 }
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16808
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 {
16813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16814 }
16815 {
16816 if (temp2)
16817 delete arg2;
16818 }
16819 return resultobj;
16820 fail:
16821 {
16822 if (temp2)
16823 delete arg2;
16824 }
16825 return NULL;
16826 }
16827
16828
16829 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16830 PyObject *resultobj;
16831 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16832 wxString *arg2 = 0 ;
16833 bool result;
16834 bool temp2 = false ;
16835 PyObject * obj0 = 0 ;
16836 PyObject * obj1 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "self",(char *) "name", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16843 if (SWIG_arg_fail(1)) SWIG_fail;
16844 {
16845 arg2 = wxString_in_helper(obj1);
16846 if (arg2 == NULL) SWIG_fail;
16847 temp2 = true;
16848 }
16849 {
16850 PyThreadState* __tstate = wxPyBeginAllowThreads();
16851 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16852
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 {
16857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16858 }
16859 {
16860 if (temp2)
16861 delete arg2;
16862 }
16863 return resultobj;
16864 fail:
16865 {
16866 if (temp2)
16867 delete arg2;
16868 }
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16876 wxString *arg2 = 0 ;
16877 bool result;
16878 bool temp2 = false ;
16879 PyObject * obj0 = 0 ;
16880 PyObject * obj1 = 0 ;
16881 char *kwnames[] = {
16882 (char *) "self",(char *) "name", NULL
16883 };
16884
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 arg2 = wxString_in_helper(obj1);
16890 if (arg2 == NULL) SWIG_fail;
16891 temp2 = true;
16892 }
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16896
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 {
16901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16902 }
16903 {
16904 if (temp2)
16905 delete arg2;
16906 }
16907 return resultobj;
16908 fail:
16909 {
16910 if (temp2)
16911 delete arg2;
16912 }
16913 return NULL;
16914 }
16915
16916
16917 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj;
16919 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16920 wxString *arg2 = 0 ;
16921 wxConfigBase::EntryType result;
16922 bool temp2 = false ;
16923 PyObject * obj0 = 0 ;
16924 PyObject * obj1 = 0 ;
16925 char *kwnames[] = {
16926 (char *) "self",(char *) "name", NULL
16927 };
16928
16929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16931 if (SWIG_arg_fail(1)) SWIG_fail;
16932 {
16933 arg2 = wxString_in_helper(obj1);
16934 if (arg2 == NULL) SWIG_fail;
16935 temp2 = true;
16936 }
16937 {
16938 PyThreadState* __tstate = wxPyBeginAllowThreads();
16939 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16940
16941 wxPyEndAllowThreads(__tstate);
16942 if (PyErr_Occurred()) SWIG_fail;
16943 }
16944 resultobj = SWIG_From_int((result));
16945 {
16946 if (temp2)
16947 delete arg2;
16948 }
16949 return resultobj;
16950 fail:
16951 {
16952 if (temp2)
16953 delete arg2;
16954 }
16955 return NULL;
16956 }
16957
16958
16959 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16960 PyObject *resultobj;
16961 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16962 wxString *arg2 = 0 ;
16963 wxString const &arg3_defvalue = wxPyEmptyString ;
16964 wxString *arg3 = (wxString *) &arg3_defvalue ;
16965 wxString result;
16966 bool temp2 = false ;
16967 bool temp3 = false ;
16968 PyObject * obj0 = 0 ;
16969 PyObject * obj1 = 0 ;
16970 PyObject * obj2 = 0 ;
16971 char *kwnames[] = {
16972 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16973 };
16974
16975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16977 if (SWIG_arg_fail(1)) SWIG_fail;
16978 {
16979 arg2 = wxString_in_helper(obj1);
16980 if (arg2 == NULL) SWIG_fail;
16981 temp2 = true;
16982 }
16983 if (obj2) {
16984 {
16985 arg3 = wxString_in_helper(obj2);
16986 if (arg3 == NULL) SWIG_fail;
16987 temp3 = true;
16988 }
16989 }
16990 {
16991 PyThreadState* __tstate = wxPyBeginAllowThreads();
16992 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
16993
16994 wxPyEndAllowThreads(__tstate);
16995 if (PyErr_Occurred()) SWIG_fail;
16996 }
16997 {
16998 #if wxUSE_UNICODE
16999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17000 #else
17001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17002 #endif
17003 }
17004 {
17005 if (temp2)
17006 delete arg2;
17007 }
17008 {
17009 if (temp3)
17010 delete arg3;
17011 }
17012 return resultobj;
17013 fail:
17014 {
17015 if (temp2)
17016 delete arg2;
17017 }
17018 {
17019 if (temp3)
17020 delete arg3;
17021 }
17022 return NULL;
17023 }
17024
17025
17026 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17027 PyObject *resultobj;
17028 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17029 wxString *arg2 = 0 ;
17030 long arg3 = (long) 0 ;
17031 long result;
17032 bool temp2 = false ;
17033 PyObject * obj0 = 0 ;
17034 PyObject * obj1 = 0 ;
17035 PyObject * obj2 = 0 ;
17036 char *kwnames[] = {
17037 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17038 };
17039
17040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17042 if (SWIG_arg_fail(1)) SWIG_fail;
17043 {
17044 arg2 = wxString_in_helper(obj1);
17045 if (arg2 == NULL) SWIG_fail;
17046 temp2 = true;
17047 }
17048 if (obj2) {
17049 {
17050 arg3 = (long)(SWIG_As_long(obj2));
17051 if (SWIG_arg_fail(3)) SWIG_fail;
17052 }
17053 }
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = SWIG_From_long((long)(result));
17063 }
17064 {
17065 if (temp2)
17066 delete arg2;
17067 }
17068 return resultobj;
17069 fail:
17070 {
17071 if (temp2)
17072 delete arg2;
17073 }
17074 return NULL;
17075 }
17076
17077
17078 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17079 PyObject *resultobj;
17080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17081 wxString *arg2 = 0 ;
17082 double arg3 = (double) 0.0 ;
17083 double result;
17084 bool temp2 = false ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 PyObject * obj2 = 0 ;
17088 char *kwnames[] = {
17089 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17090 };
17091
17092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17094 if (SWIG_arg_fail(1)) SWIG_fail;
17095 {
17096 arg2 = wxString_in_helper(obj1);
17097 if (arg2 == NULL) SWIG_fail;
17098 temp2 = true;
17099 }
17100 if (obj2) {
17101 {
17102 arg3 = (double)(SWIG_As_double(obj2));
17103 if (SWIG_arg_fail(3)) SWIG_fail;
17104 }
17105 }
17106 {
17107 PyThreadState* __tstate = wxPyBeginAllowThreads();
17108 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17109
17110 wxPyEndAllowThreads(__tstate);
17111 if (PyErr_Occurred()) SWIG_fail;
17112 }
17113 {
17114 resultobj = SWIG_From_double((double)(result));
17115 }
17116 {
17117 if (temp2)
17118 delete arg2;
17119 }
17120 return resultobj;
17121 fail:
17122 {
17123 if (temp2)
17124 delete arg2;
17125 }
17126 return NULL;
17127 }
17128
17129
17130 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17131 PyObject *resultobj;
17132 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17133 wxString *arg2 = 0 ;
17134 bool arg3 = (bool) false ;
17135 bool result;
17136 bool temp2 = false ;
17137 PyObject * obj0 = 0 ;
17138 PyObject * obj1 = 0 ;
17139 PyObject * obj2 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17146 if (SWIG_arg_fail(1)) SWIG_fail;
17147 {
17148 arg2 = wxString_in_helper(obj1);
17149 if (arg2 == NULL) SWIG_fail;
17150 temp2 = true;
17151 }
17152 if (obj2) {
17153 {
17154 arg3 = (bool)(SWIG_As_bool(obj2));
17155 if (SWIG_arg_fail(3)) SWIG_fail;
17156 }
17157 }
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17161
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 {
17166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17167 }
17168 {
17169 if (temp2)
17170 delete arg2;
17171 }
17172 return resultobj;
17173 fail:
17174 {
17175 if (temp2)
17176 delete arg2;
17177 }
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
17184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17185 wxString *arg2 = 0 ;
17186 wxString *arg3 = 0 ;
17187 bool result;
17188 bool temp2 = false ;
17189 bool temp3 = false ;
17190 PyObject * obj0 = 0 ;
17191 PyObject * obj1 = 0 ;
17192 PyObject * obj2 = 0 ;
17193 char *kwnames[] = {
17194 (char *) "self",(char *) "key",(char *) "value", NULL
17195 };
17196
17197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17199 if (SWIG_arg_fail(1)) SWIG_fail;
17200 {
17201 arg2 = wxString_in_helper(obj1);
17202 if (arg2 == NULL) SWIG_fail;
17203 temp2 = true;
17204 }
17205 {
17206 arg3 = wxString_in_helper(obj2);
17207 if (arg3 == NULL) SWIG_fail;
17208 temp3 = true;
17209 }
17210 {
17211 PyThreadState* __tstate = wxPyBeginAllowThreads();
17212 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17213
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 {
17218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17219 }
17220 {
17221 if (temp2)
17222 delete arg2;
17223 }
17224 {
17225 if (temp3)
17226 delete arg3;
17227 }
17228 return resultobj;
17229 fail:
17230 {
17231 if (temp2)
17232 delete arg2;
17233 }
17234 {
17235 if (temp3)
17236 delete arg3;
17237 }
17238 return NULL;
17239 }
17240
17241
17242 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj;
17244 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17245 wxString *arg2 = 0 ;
17246 long arg3 ;
17247 bool result;
17248 bool temp2 = false ;
17249 PyObject * obj0 = 0 ;
17250 PyObject * obj1 = 0 ;
17251 PyObject * obj2 = 0 ;
17252 char *kwnames[] = {
17253 (char *) "self",(char *) "key",(char *) "value", NULL
17254 };
17255
17256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17258 if (SWIG_arg_fail(1)) SWIG_fail;
17259 {
17260 arg2 = wxString_in_helper(obj1);
17261 if (arg2 == NULL) SWIG_fail;
17262 temp2 = true;
17263 }
17264 {
17265 arg3 = (long)(SWIG_As_long(obj2));
17266 if (SWIG_arg_fail(3)) SWIG_fail;
17267 }
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17271
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 {
17276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17277 }
17278 {
17279 if (temp2)
17280 delete arg2;
17281 }
17282 return resultobj;
17283 fail:
17284 {
17285 if (temp2)
17286 delete arg2;
17287 }
17288 return NULL;
17289 }
17290
17291
17292 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj;
17294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17295 wxString *arg2 = 0 ;
17296 double arg3 ;
17297 bool result;
17298 bool temp2 = false ;
17299 PyObject * obj0 = 0 ;
17300 PyObject * obj1 = 0 ;
17301 PyObject * obj2 = 0 ;
17302 char *kwnames[] = {
17303 (char *) "self",(char *) "key",(char *) "value", NULL
17304 };
17305
17306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17308 if (SWIG_arg_fail(1)) SWIG_fail;
17309 {
17310 arg2 = wxString_in_helper(obj1);
17311 if (arg2 == NULL) SWIG_fail;
17312 temp2 = true;
17313 }
17314 {
17315 arg3 = (double)(SWIG_As_double(obj2));
17316 if (SWIG_arg_fail(3)) SWIG_fail;
17317 }
17318 {
17319 PyThreadState* __tstate = wxPyBeginAllowThreads();
17320 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17321
17322 wxPyEndAllowThreads(__tstate);
17323 if (PyErr_Occurred()) SWIG_fail;
17324 }
17325 {
17326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17327 }
17328 {
17329 if (temp2)
17330 delete arg2;
17331 }
17332 return resultobj;
17333 fail:
17334 {
17335 if (temp2)
17336 delete arg2;
17337 }
17338 return NULL;
17339 }
17340
17341
17342 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17343 PyObject *resultobj;
17344 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17345 wxString *arg2 = 0 ;
17346 bool arg3 ;
17347 bool result;
17348 bool temp2 = false ;
17349 PyObject * obj0 = 0 ;
17350 PyObject * obj1 = 0 ;
17351 PyObject * obj2 = 0 ;
17352 char *kwnames[] = {
17353 (char *) "self",(char *) "key",(char *) "value", NULL
17354 };
17355
17356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17358 if (SWIG_arg_fail(1)) SWIG_fail;
17359 {
17360 arg2 = wxString_in_helper(obj1);
17361 if (arg2 == NULL) SWIG_fail;
17362 temp2 = true;
17363 }
17364 {
17365 arg3 = (bool)(SWIG_As_bool(obj2));
17366 if (SWIG_arg_fail(3)) SWIG_fail;
17367 }
17368 {
17369 PyThreadState* __tstate = wxPyBeginAllowThreads();
17370 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17371
17372 wxPyEndAllowThreads(__tstate);
17373 if (PyErr_Occurred()) SWIG_fail;
17374 }
17375 {
17376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377 }
17378 {
17379 if (temp2)
17380 delete arg2;
17381 }
17382 return resultobj;
17383 fail:
17384 {
17385 if (temp2)
17386 delete arg2;
17387 }
17388 return NULL;
17389 }
17390
17391
17392 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17393 PyObject *resultobj;
17394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17395 bool arg2 = (bool) false ;
17396 bool result;
17397 PyObject * obj0 = 0 ;
17398 PyObject * obj1 = 0 ;
17399 char *kwnames[] = {
17400 (char *) "self",(char *) "currentOnly", NULL
17401 };
17402
17403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17405 if (SWIG_arg_fail(1)) SWIG_fail;
17406 if (obj1) {
17407 {
17408 arg2 = (bool)(SWIG_As_bool(obj1));
17409 if (SWIG_arg_fail(2)) SWIG_fail;
17410 }
17411 }
17412 {
17413 PyThreadState* __tstate = wxPyBeginAllowThreads();
17414 result = (bool)(arg1)->Flush(arg2);
17415
17416 wxPyEndAllowThreads(__tstate);
17417 if (PyErr_Occurred()) SWIG_fail;
17418 }
17419 {
17420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17421 }
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17429 PyObject *resultobj;
17430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17431 wxString *arg2 = 0 ;
17432 wxString *arg3 = 0 ;
17433 bool result;
17434 bool temp2 = false ;
17435 bool temp3 = false ;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 PyObject * obj2 = 0 ;
17439 char *kwnames[] = {
17440 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17441 };
17442
17443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17445 if (SWIG_arg_fail(1)) SWIG_fail;
17446 {
17447 arg2 = wxString_in_helper(obj1);
17448 if (arg2 == NULL) SWIG_fail;
17449 temp2 = true;
17450 }
17451 {
17452 arg3 = wxString_in_helper(obj2);
17453 if (arg3 == NULL) SWIG_fail;
17454 temp3 = true;
17455 }
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17459
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 {
17464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17465 }
17466 {
17467 if (temp2)
17468 delete arg2;
17469 }
17470 {
17471 if (temp3)
17472 delete arg3;
17473 }
17474 return resultobj;
17475 fail:
17476 {
17477 if (temp2)
17478 delete arg2;
17479 }
17480 {
17481 if (temp3)
17482 delete arg3;
17483 }
17484 return NULL;
17485 }
17486
17487
17488 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17489 PyObject *resultobj;
17490 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17491 wxString *arg2 = 0 ;
17492 wxString *arg3 = 0 ;
17493 bool result;
17494 bool temp2 = false ;
17495 bool temp3 = false ;
17496 PyObject * obj0 = 0 ;
17497 PyObject * obj1 = 0 ;
17498 PyObject * obj2 = 0 ;
17499 char *kwnames[] = {
17500 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17501 };
17502
17503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17505 if (SWIG_arg_fail(1)) SWIG_fail;
17506 {
17507 arg2 = wxString_in_helper(obj1);
17508 if (arg2 == NULL) SWIG_fail;
17509 temp2 = true;
17510 }
17511 {
17512 arg3 = wxString_in_helper(obj2);
17513 if (arg3 == NULL) SWIG_fail;
17514 temp3 = true;
17515 }
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17519
17520 wxPyEndAllowThreads(__tstate);
17521 if (PyErr_Occurred()) SWIG_fail;
17522 }
17523 {
17524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17525 }
17526 {
17527 if (temp2)
17528 delete arg2;
17529 }
17530 {
17531 if (temp3)
17532 delete arg3;
17533 }
17534 return resultobj;
17535 fail:
17536 {
17537 if (temp2)
17538 delete arg2;
17539 }
17540 {
17541 if (temp3)
17542 delete arg3;
17543 }
17544 return NULL;
17545 }
17546
17547
17548 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17549 PyObject *resultobj;
17550 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17551 wxString *arg2 = 0 ;
17552 bool arg3 = (bool) true ;
17553 bool result;
17554 bool temp2 = false ;
17555 PyObject * obj0 = 0 ;
17556 PyObject * obj1 = 0 ;
17557 PyObject * obj2 = 0 ;
17558 char *kwnames[] = {
17559 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17560 };
17561
17562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17564 if (SWIG_arg_fail(1)) SWIG_fail;
17565 {
17566 arg2 = wxString_in_helper(obj1);
17567 if (arg2 == NULL) SWIG_fail;
17568 temp2 = true;
17569 }
17570 if (obj2) {
17571 {
17572 arg3 = (bool)(SWIG_As_bool(obj2));
17573 if (SWIG_arg_fail(3)) SWIG_fail;
17574 }
17575 }
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17579
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 {
17584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17585 }
17586 {
17587 if (temp2)
17588 delete arg2;
17589 }
17590 return resultobj;
17591 fail:
17592 {
17593 if (temp2)
17594 delete arg2;
17595 }
17596 return NULL;
17597 }
17598
17599
17600 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17601 PyObject *resultobj;
17602 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17603 wxString *arg2 = 0 ;
17604 bool result;
17605 bool temp2 = false ;
17606 PyObject * obj0 = 0 ;
17607 PyObject * obj1 = 0 ;
17608 char *kwnames[] = {
17609 (char *) "self",(char *) "key", NULL
17610 };
17611
17612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17614 if (SWIG_arg_fail(1)) SWIG_fail;
17615 {
17616 arg2 = wxString_in_helper(obj1);
17617 if (arg2 == NULL) SWIG_fail;
17618 temp2 = true;
17619 }
17620 {
17621 PyThreadState* __tstate = wxPyBeginAllowThreads();
17622 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17623
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 {
17628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17629 }
17630 {
17631 if (temp2)
17632 delete arg2;
17633 }
17634 return resultobj;
17635 fail:
17636 {
17637 if (temp2)
17638 delete arg2;
17639 }
17640 return NULL;
17641 }
17642
17643
17644 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17645 PyObject *resultobj;
17646 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17647 bool result;
17648 PyObject * obj0 = 0 ;
17649 char *kwnames[] = {
17650 (char *) "self", NULL
17651 };
17652
17653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17655 if (SWIG_arg_fail(1)) SWIG_fail;
17656 {
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 result = (bool)(arg1)->DeleteAll();
17659
17660 wxPyEndAllowThreads(__tstate);
17661 if (PyErr_Occurred()) SWIG_fail;
17662 }
17663 {
17664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17665 }
17666 return resultobj;
17667 fail:
17668 return NULL;
17669 }
17670
17671
17672 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17673 PyObject *resultobj;
17674 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17675 bool arg2 = (bool) true ;
17676 PyObject * obj0 = 0 ;
17677 PyObject * obj1 = 0 ;
17678 char *kwnames[] = {
17679 (char *) "self",(char *) "doIt", NULL
17680 };
17681
17682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) 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 if (obj1) {
17686 {
17687 arg2 = (bool)(SWIG_As_bool(obj1));
17688 if (SWIG_arg_fail(2)) SWIG_fail;
17689 }
17690 }
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 (arg1)->SetExpandEnvVars(arg2);
17694
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 Py_INCREF(Py_None); resultobj = Py_None;
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj;
17707 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17708 bool result;
17709 PyObject * obj0 = 0 ;
17710 char *kwnames[] = {
17711 (char *) "self", NULL
17712 };
17713
17714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17716 if (SWIG_arg_fail(1)) SWIG_fail;
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17720
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 {
17725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17726 }
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj;
17735 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17736 bool arg2 = (bool) true ;
17737 PyObject * obj0 = 0 ;
17738 PyObject * obj1 = 0 ;
17739 char *kwnames[] = {
17740 (char *) "self",(char *) "doIt", NULL
17741 };
17742
17743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17745 if (SWIG_arg_fail(1)) SWIG_fail;
17746 if (obj1) {
17747 {
17748 arg2 = (bool)(SWIG_As_bool(obj1));
17749 if (SWIG_arg_fail(2)) SWIG_fail;
17750 }
17751 }
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 (arg1)->SetRecordDefaults(arg2);
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 Py_INCREF(Py_None); resultobj = Py_None;
17760 return resultobj;
17761 fail:
17762 return NULL;
17763 }
17764
17765
17766 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj;
17768 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17769 bool result;
17770 PyObject * obj0 = 0 ;
17771 char *kwnames[] = {
17772 (char *) "self", NULL
17773 };
17774
17775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17777 if (SWIG_arg_fail(1)) SWIG_fail;
17778 {
17779 PyThreadState* __tstate = wxPyBeginAllowThreads();
17780 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17781
17782 wxPyEndAllowThreads(__tstate);
17783 if (PyErr_Occurred()) SWIG_fail;
17784 }
17785 {
17786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17787 }
17788 return resultobj;
17789 fail:
17790 return NULL;
17791 }
17792
17793
17794 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17795 PyObject *resultobj;
17796 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17797 wxString *arg2 = 0 ;
17798 wxString result;
17799 bool temp2 = false ;
17800 PyObject * obj0 = 0 ;
17801 PyObject * obj1 = 0 ;
17802 char *kwnames[] = {
17803 (char *) "self",(char *) "str", NULL
17804 };
17805
17806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(1)) SWIG_fail;
17809 {
17810 arg2 = wxString_in_helper(obj1);
17811 if (arg2 == NULL) SWIG_fail;
17812 temp2 = true;
17813 }
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17817
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 #if wxUSE_UNICODE
17823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17824 #else
17825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17826 #endif
17827 }
17828 {
17829 if (temp2)
17830 delete arg2;
17831 }
17832 return resultobj;
17833 fail:
17834 {
17835 if (temp2)
17836 delete arg2;
17837 }
17838 return NULL;
17839 }
17840
17841
17842 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj;
17844 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17845 wxString result;
17846 PyObject * obj0 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 result = ((wxConfigBase const *)arg1)->GetAppName();
17857
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 {
17862 #if wxUSE_UNICODE
17863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17864 #else
17865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17866 #endif
17867 }
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17875 PyObject *resultobj;
17876 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17877 wxString result;
17878 PyObject * obj0 = 0 ;
17879 char *kwnames[] = {
17880 (char *) "self", NULL
17881 };
17882
17883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17885 if (SWIG_arg_fail(1)) SWIG_fail;
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 result = ((wxConfigBase const *)arg1)->GetVendorName();
17889
17890 wxPyEndAllowThreads(__tstate);
17891 if (PyErr_Occurred()) SWIG_fail;
17892 }
17893 {
17894 #if wxUSE_UNICODE
17895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17896 #else
17897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17898 #endif
17899 }
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj;
17908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17909 wxString *arg2 = 0 ;
17910 bool temp2 = false ;
17911 PyObject * obj0 = 0 ;
17912 PyObject * obj1 = 0 ;
17913 char *kwnames[] = {
17914 (char *) "self",(char *) "appName", NULL
17915 };
17916
17917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17919 if (SWIG_arg_fail(1)) SWIG_fail;
17920 {
17921 arg2 = wxString_in_helper(obj1);
17922 if (arg2 == NULL) SWIG_fail;
17923 temp2 = true;
17924 }
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 (arg1)->SetAppName((wxString const &)*arg2);
17928
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 Py_INCREF(Py_None); resultobj = Py_None;
17933 {
17934 if (temp2)
17935 delete arg2;
17936 }
17937 return resultobj;
17938 fail:
17939 {
17940 if (temp2)
17941 delete arg2;
17942 }
17943 return NULL;
17944 }
17945
17946
17947 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17948 PyObject *resultobj;
17949 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17950 wxString *arg2 = 0 ;
17951 bool temp2 = false ;
17952 PyObject * obj0 = 0 ;
17953 PyObject * obj1 = 0 ;
17954 char *kwnames[] = {
17955 (char *) "self",(char *) "vendorName", NULL
17956 };
17957
17958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17960 if (SWIG_arg_fail(1)) SWIG_fail;
17961 {
17962 arg2 = wxString_in_helper(obj1);
17963 if (arg2 == NULL) SWIG_fail;
17964 temp2 = true;
17965 }
17966 {
17967 PyThreadState* __tstate = wxPyBeginAllowThreads();
17968 (arg1)->SetVendorName((wxString const &)*arg2);
17969
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 Py_INCREF(Py_None); resultobj = Py_None;
17974 {
17975 if (temp2)
17976 delete arg2;
17977 }
17978 return resultobj;
17979 fail:
17980 {
17981 if (temp2)
17982 delete arg2;
17983 }
17984 return NULL;
17985 }
17986
17987
17988 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
17989 PyObject *resultobj;
17990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17991 long arg2 ;
17992 PyObject * obj0 = 0 ;
17993 PyObject * obj1 = 0 ;
17994 char *kwnames[] = {
17995 (char *) "self",(char *) "style", NULL
17996 };
17997
17998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
17999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18000 if (SWIG_arg_fail(1)) SWIG_fail;
18001 {
18002 arg2 = (long)(SWIG_As_long(obj1));
18003 if (SWIG_arg_fail(2)) SWIG_fail;
18004 }
18005 {
18006 PyThreadState* __tstate = wxPyBeginAllowThreads();
18007 (arg1)->SetStyle(arg2);
18008
18009 wxPyEndAllowThreads(__tstate);
18010 if (PyErr_Occurred()) SWIG_fail;
18011 }
18012 Py_INCREF(Py_None); resultobj = Py_None;
18013 return resultobj;
18014 fail:
18015 return NULL;
18016 }
18017
18018
18019 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj;
18021 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18022 long result;
18023 PyObject * obj0 = 0 ;
18024 char *kwnames[] = {
18025 (char *) "self", NULL
18026 };
18027
18028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(1)) SWIG_fail;
18031 {
18032 PyThreadState* __tstate = wxPyBeginAllowThreads();
18033 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18034
18035 wxPyEndAllowThreads(__tstate);
18036 if (PyErr_Occurred()) SWIG_fail;
18037 }
18038 {
18039 resultobj = SWIG_From_long((long)(result));
18040 }
18041 return resultobj;
18042 fail:
18043 return NULL;
18044 }
18045
18046
18047 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18048 PyObject *obj;
18049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18050 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18051 Py_INCREF(obj);
18052 return Py_BuildValue((char *)"");
18053 }
18054 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18055 PyObject *resultobj;
18056 wxString const &arg1_defvalue = wxPyEmptyString ;
18057 wxString *arg1 = (wxString *) &arg1_defvalue ;
18058 wxString const &arg2_defvalue = wxPyEmptyString ;
18059 wxString *arg2 = (wxString *) &arg2_defvalue ;
18060 wxString const &arg3_defvalue = wxPyEmptyString ;
18061 wxString *arg3 = (wxString *) &arg3_defvalue ;
18062 wxString const &arg4_defvalue = wxPyEmptyString ;
18063 wxString *arg4 = (wxString *) &arg4_defvalue ;
18064 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18065 wxConfig *result;
18066 bool temp1 = false ;
18067 bool temp2 = false ;
18068 bool temp3 = false ;
18069 bool temp4 = false ;
18070 PyObject * obj0 = 0 ;
18071 PyObject * obj1 = 0 ;
18072 PyObject * obj2 = 0 ;
18073 PyObject * obj3 = 0 ;
18074 PyObject * obj4 = 0 ;
18075 char *kwnames[] = {
18076 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18077 };
18078
18079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18080 if (obj0) {
18081 {
18082 arg1 = wxString_in_helper(obj0);
18083 if (arg1 == NULL) SWIG_fail;
18084 temp1 = true;
18085 }
18086 }
18087 if (obj1) {
18088 {
18089 arg2 = wxString_in_helper(obj1);
18090 if (arg2 == NULL) SWIG_fail;
18091 temp2 = true;
18092 }
18093 }
18094 if (obj2) {
18095 {
18096 arg3 = wxString_in_helper(obj2);
18097 if (arg3 == NULL) SWIG_fail;
18098 temp3 = true;
18099 }
18100 }
18101 if (obj3) {
18102 {
18103 arg4 = wxString_in_helper(obj3);
18104 if (arg4 == NULL) SWIG_fail;
18105 temp4 = true;
18106 }
18107 }
18108 if (obj4) {
18109 {
18110 arg5 = (long)(SWIG_As_long(obj4));
18111 if (SWIG_arg_fail(5)) SWIG_fail;
18112 }
18113 }
18114 {
18115 PyThreadState* __tstate = wxPyBeginAllowThreads();
18116 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18117
18118 wxPyEndAllowThreads(__tstate);
18119 if (PyErr_Occurred()) SWIG_fail;
18120 }
18121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18122 {
18123 if (temp1)
18124 delete arg1;
18125 }
18126 {
18127 if (temp2)
18128 delete arg2;
18129 }
18130 {
18131 if (temp3)
18132 delete arg3;
18133 }
18134 {
18135 if (temp4)
18136 delete arg4;
18137 }
18138 return resultobj;
18139 fail:
18140 {
18141 if (temp1)
18142 delete arg1;
18143 }
18144 {
18145 if (temp2)
18146 delete arg2;
18147 }
18148 {
18149 if (temp3)
18150 delete arg3;
18151 }
18152 {
18153 if (temp4)
18154 delete arg4;
18155 }
18156 return NULL;
18157 }
18158
18159
18160 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18161 PyObject *resultobj;
18162 wxConfig *arg1 = (wxConfig *) 0 ;
18163 PyObject * obj0 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 delete arg1;
18174
18175 wxPyEndAllowThreads(__tstate);
18176 if (PyErr_Occurred()) SWIG_fail;
18177 }
18178 Py_INCREF(Py_None); resultobj = Py_None;
18179 return resultobj;
18180 fail:
18181 return NULL;
18182 }
18183
18184
18185 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18186 PyObject *obj;
18187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18188 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18189 Py_INCREF(obj);
18190 return Py_BuildValue((char *)"");
18191 }
18192 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18193 PyObject *resultobj;
18194 wxString const &arg1_defvalue = wxPyEmptyString ;
18195 wxString *arg1 = (wxString *) &arg1_defvalue ;
18196 wxString const &arg2_defvalue = wxPyEmptyString ;
18197 wxString *arg2 = (wxString *) &arg2_defvalue ;
18198 wxString const &arg3_defvalue = wxPyEmptyString ;
18199 wxString *arg3 = (wxString *) &arg3_defvalue ;
18200 wxString const &arg4_defvalue = wxPyEmptyString ;
18201 wxString *arg4 = (wxString *) &arg4_defvalue ;
18202 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18203 wxFileConfig *result;
18204 bool temp1 = false ;
18205 bool temp2 = false ;
18206 bool temp3 = false ;
18207 bool temp4 = false ;
18208 PyObject * obj0 = 0 ;
18209 PyObject * obj1 = 0 ;
18210 PyObject * obj2 = 0 ;
18211 PyObject * obj3 = 0 ;
18212 PyObject * obj4 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18218 if (obj0) {
18219 {
18220 arg1 = wxString_in_helper(obj0);
18221 if (arg1 == NULL) SWIG_fail;
18222 temp1 = true;
18223 }
18224 }
18225 if (obj1) {
18226 {
18227 arg2 = wxString_in_helper(obj1);
18228 if (arg2 == NULL) SWIG_fail;
18229 temp2 = true;
18230 }
18231 }
18232 if (obj2) {
18233 {
18234 arg3 = wxString_in_helper(obj2);
18235 if (arg3 == NULL) SWIG_fail;
18236 temp3 = true;
18237 }
18238 }
18239 if (obj3) {
18240 {
18241 arg4 = wxString_in_helper(obj3);
18242 if (arg4 == NULL) SWIG_fail;
18243 temp4 = true;
18244 }
18245 }
18246 if (obj4) {
18247 {
18248 arg5 = (long)(SWIG_As_long(obj4));
18249 if (SWIG_arg_fail(5)) SWIG_fail;
18250 }
18251 }
18252 {
18253 PyThreadState* __tstate = wxPyBeginAllowThreads();
18254 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18255
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18260 {
18261 if (temp1)
18262 delete arg1;
18263 }
18264 {
18265 if (temp2)
18266 delete arg2;
18267 }
18268 {
18269 if (temp3)
18270 delete arg3;
18271 }
18272 {
18273 if (temp4)
18274 delete arg4;
18275 }
18276 return resultobj;
18277 fail:
18278 {
18279 if (temp1)
18280 delete arg1;
18281 }
18282 {
18283 if (temp2)
18284 delete arg2;
18285 }
18286 {
18287 if (temp3)
18288 delete arg3;
18289 }
18290 {
18291 if (temp4)
18292 delete arg4;
18293 }
18294 return NULL;
18295 }
18296
18297
18298 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj;
18300 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18301 PyObject * obj0 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 delete arg1;
18312
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 Py_INCREF(Py_None); resultobj = Py_None;
18317 return resultobj;
18318 fail:
18319 return NULL;
18320 }
18321
18322
18323 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18324 PyObject *obj;
18325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18326 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18327 Py_INCREF(obj);
18328 return Py_BuildValue((char *)"");
18329 }
18330 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18331 PyObject *resultobj;
18332 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18333 wxString *arg2 = 0 ;
18334 wxConfigPathChanger *result;
18335 bool temp2 = false ;
18336 PyObject * obj0 = 0 ;
18337 PyObject * obj1 = 0 ;
18338 char *kwnames[] = {
18339 (char *) "config",(char *) "entry", NULL
18340 };
18341
18342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18344 if (SWIG_arg_fail(1)) SWIG_fail;
18345 {
18346 arg2 = wxString_in_helper(obj1);
18347 if (arg2 == NULL) SWIG_fail;
18348 temp2 = true;
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18353
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18358 {
18359 if (temp2)
18360 delete arg2;
18361 }
18362 return resultobj;
18363 fail:
18364 {
18365 if (temp2)
18366 delete arg2;
18367 }
18368 return NULL;
18369 }
18370
18371
18372 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18373 PyObject *resultobj;
18374 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18375 PyObject * obj0 = 0 ;
18376 char *kwnames[] = {
18377 (char *) "self", NULL
18378 };
18379
18380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18382 if (SWIG_arg_fail(1)) SWIG_fail;
18383 {
18384 PyThreadState* __tstate = wxPyBeginAllowThreads();
18385 delete arg1;
18386
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 Py_INCREF(Py_None); resultobj = Py_None;
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18398 PyObject *resultobj;
18399 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18400 wxString *result;
18401 PyObject * obj0 = 0 ;
18402 char *kwnames[] = {
18403 (char *) "self", NULL
18404 };
18405
18406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18408 if (SWIG_arg_fail(1)) SWIG_fail;
18409 {
18410 PyThreadState* __tstate = wxPyBeginAllowThreads();
18411 {
18412 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18413 result = (wxString *) &_result_ref;
18414 }
18415
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 {
18420 #if wxUSE_UNICODE
18421 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18422 #else
18423 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18424 #endif
18425 }
18426 return resultobj;
18427 fail:
18428 return NULL;
18429 }
18430
18431
18432 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18433 PyObject *obj;
18434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18435 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18436 Py_INCREF(obj);
18437 return Py_BuildValue((char *)"");
18438 }
18439 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18440 PyObject *resultobj;
18441 wxString *arg1 = 0 ;
18442 wxString result;
18443 bool temp1 = false ;
18444 PyObject * obj0 = 0 ;
18445 char *kwnames[] = {
18446 (char *) "sz", NULL
18447 };
18448
18449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18450 {
18451 arg1 = wxString_in_helper(obj0);
18452 if (arg1 == NULL) SWIG_fail;
18453 temp1 = true;
18454 }
18455 {
18456 PyThreadState* __tstate = wxPyBeginAllowThreads();
18457 result = wxExpandEnvVars((wxString const &)*arg1);
18458
18459 wxPyEndAllowThreads(__tstate);
18460 if (PyErr_Occurred()) SWIG_fail;
18461 }
18462 {
18463 #if wxUSE_UNICODE
18464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18465 #else
18466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18467 #endif
18468 }
18469 {
18470 if (temp1)
18471 delete arg1;
18472 }
18473 return resultobj;
18474 fail:
18475 {
18476 if (temp1)
18477 delete arg1;
18478 }
18479 return NULL;
18480 }
18481
18482
18483 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18484 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18485 return 1;
18486 }
18487
18488
18489 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18490 PyObject *pyobj;
18491
18492 {
18493 #if wxUSE_UNICODE
18494 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18495 #else
18496 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18497 #endif
18498 }
18499 return pyobj;
18500 }
18501
18502
18503 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18504 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18505 return 1;
18506 }
18507
18508
18509 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18510 PyObject *pyobj;
18511
18512 {
18513 #if wxUSE_UNICODE
18514 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18515 #else
18516 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18517 #endif
18518 }
18519 return pyobj;
18520 }
18521
18522
18523 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18524 PyObject *resultobj;
18525 wxDateTime::Country arg1 ;
18526 PyObject * obj0 = 0 ;
18527 char *kwnames[] = {
18528 (char *) "country", NULL
18529 };
18530
18531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18532 {
18533 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18534 if (SWIG_arg_fail(1)) SWIG_fail;
18535 }
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18539
18540 wxPyEndAllowThreads(__tstate);
18541 if (PyErr_Occurred()) SWIG_fail;
18542 }
18543 Py_INCREF(Py_None); resultobj = Py_None;
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18551 PyObject *resultobj;
18552 wxDateTime::Country result;
18553 char *kwnames[] = {
18554 NULL
18555 };
18556
18557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18558 {
18559 PyThreadState* __tstate = wxPyBeginAllowThreads();
18560 result = (wxDateTime::Country)wxDateTime::GetCountry();
18561
18562 wxPyEndAllowThreads(__tstate);
18563 if (PyErr_Occurred()) SWIG_fail;
18564 }
18565 resultobj = SWIG_From_int((result));
18566 return resultobj;
18567 fail:
18568 return NULL;
18569 }
18570
18571
18572 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18573 PyObject *resultobj;
18574 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18575 bool result;
18576 PyObject * obj0 = 0 ;
18577 char *kwnames[] = {
18578 (char *) "country", NULL
18579 };
18580
18581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18582 if (obj0) {
18583 {
18584 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18585 if (SWIG_arg_fail(1)) SWIG_fail;
18586 }
18587 }
18588 {
18589 PyThreadState* __tstate = wxPyBeginAllowThreads();
18590 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18591
18592 wxPyEndAllowThreads(__tstate);
18593 if (PyErr_Occurred()) SWIG_fail;
18594 }
18595 {
18596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18597 }
18598 return resultobj;
18599 fail:
18600 return NULL;
18601 }
18602
18603
18604 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18605 PyObject *resultobj;
18606 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18607 int result;
18608 PyObject * obj0 = 0 ;
18609 char *kwnames[] = {
18610 (char *) "cal", NULL
18611 };
18612
18613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18614 if (obj0) {
18615 {
18616 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18617 if (SWIG_arg_fail(1)) SWIG_fail;
18618 }
18619 }
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18623
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 {
18628 resultobj = SWIG_From_int((int)(result));
18629 }
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj;
18638 int arg1 ;
18639 int result;
18640 PyObject * obj0 = 0 ;
18641 char *kwnames[] = {
18642 (char *) "year", NULL
18643 };
18644
18645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18646 {
18647 arg1 = (int)(SWIG_As_int(obj0));
18648 if (SWIG_arg_fail(1)) SWIG_fail;
18649 }
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 result = (int)wxDateTime::ConvertYearToBC(arg1);
18653
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 {
18658 resultobj = SWIG_From_int((int)(result));
18659 }
18660 return resultobj;
18661 fail:
18662 return NULL;
18663 }
18664
18665
18666 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18667 PyObject *resultobj;
18668 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18669 wxDateTime::Month result;
18670 PyObject * obj0 = 0 ;
18671 char *kwnames[] = {
18672 (char *) "cal", NULL
18673 };
18674
18675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18676 if (obj0) {
18677 {
18678 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18679 if (SWIG_arg_fail(1)) SWIG_fail;
18680 }
18681 }
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18685
18686 wxPyEndAllowThreads(__tstate);
18687 if (PyErr_Occurred()) SWIG_fail;
18688 }
18689 resultobj = SWIG_From_int((result));
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18697 PyObject *resultobj;
18698 int arg1 = (int) wxDateTime::Inv_Year ;
18699 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18700 bool result;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "year",(char *) "cal", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18708 if (obj0) {
18709 {
18710 arg1 = (int)(SWIG_As_int(obj0));
18711 if (SWIG_arg_fail(1)) SWIG_fail;
18712 }
18713 }
18714 if (obj1) {
18715 {
18716 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18717 if (SWIG_arg_fail(2)) SWIG_fail;
18718 }
18719 }
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18723
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 {
18728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18729 }
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj;
18738 int arg1 = (int) wxDateTime::Inv_Year ;
18739 int result;
18740 PyObject * obj0 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "year", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18746 if (obj0) {
18747 {
18748 arg1 = (int)(SWIG_As_int(obj0));
18749 if (SWIG_arg_fail(1)) SWIG_fail;
18750 }
18751 }
18752 {
18753 PyThreadState* __tstate = wxPyBeginAllowThreads();
18754 result = (int)wxDateTime::GetCentury(arg1);
18755
18756 wxPyEndAllowThreads(__tstate);
18757 if (PyErr_Occurred()) SWIG_fail;
18758 }
18759 {
18760 resultobj = SWIG_From_int((int)(result));
18761 }
18762 return resultobj;
18763 fail:
18764 return NULL;
18765 }
18766
18767
18768 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18769 PyObject *resultobj;
18770 int arg1 ;
18771 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18772 int result;
18773 PyObject * obj0 = 0 ;
18774 PyObject * obj1 = 0 ;
18775 char *kwnames[] = {
18776 (char *) "year",(char *) "cal", NULL
18777 };
18778
18779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18780 {
18781 arg1 = (int)(SWIG_As_int(obj0));
18782 if (SWIG_arg_fail(1)) SWIG_fail;
18783 }
18784 if (obj1) {
18785 {
18786 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18787 if (SWIG_arg_fail(2)) SWIG_fail;
18788 }
18789 }
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = SWIG_From_int((int)(result));
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxDateTime::Month arg1 ;
18809 int arg2 = (int) wxDateTime::Inv_Year ;
18810 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18811 int result;
18812 PyObject * obj0 = 0 ;
18813 PyObject * obj1 = 0 ;
18814 PyObject * obj2 = 0 ;
18815 char *kwnames[] = {
18816 (char *) "month",(char *) "year",(char *) "cal", NULL
18817 };
18818
18819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18820 {
18821 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18822 if (SWIG_arg_fail(1)) SWIG_fail;
18823 }
18824 if (obj1) {
18825 {
18826 arg2 = (int)(SWIG_As_int(obj1));
18827 if (SWIG_arg_fail(2)) SWIG_fail;
18828 }
18829 }
18830 if (obj2) {
18831 {
18832 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18833 if (SWIG_arg_fail(3)) SWIG_fail;
18834 }
18835 }
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18839
18840 wxPyEndAllowThreads(__tstate);
18841 if (PyErr_Occurred()) SWIG_fail;
18842 }
18843 {
18844 resultobj = SWIG_From_int((int)(result));
18845 }
18846 return resultobj;
18847 fail:
18848 return NULL;
18849 }
18850
18851
18852 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18853 PyObject *resultobj;
18854 wxDateTime::Month arg1 ;
18855 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18856 wxString result;
18857 PyObject * obj0 = 0 ;
18858 PyObject * obj1 = 0 ;
18859 char *kwnames[] = {
18860 (char *) "month",(char *) "flags", NULL
18861 };
18862
18863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18864 {
18865 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18866 if (SWIG_arg_fail(1)) SWIG_fail;
18867 }
18868 if (obj1) {
18869 {
18870 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18871 if (SWIG_arg_fail(2)) SWIG_fail;
18872 }
18873 }
18874 {
18875 PyThreadState* __tstate = wxPyBeginAllowThreads();
18876 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18877
18878 wxPyEndAllowThreads(__tstate);
18879 if (PyErr_Occurred()) SWIG_fail;
18880 }
18881 {
18882 #if wxUSE_UNICODE
18883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18884 #else
18885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18886 #endif
18887 }
18888 return resultobj;
18889 fail:
18890 return NULL;
18891 }
18892
18893
18894 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18895 PyObject *resultobj;
18896 wxDateTime::WeekDay arg1 ;
18897 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18898 wxString result;
18899 PyObject * obj0 = 0 ;
18900 PyObject * obj1 = 0 ;
18901 char *kwnames[] = {
18902 (char *) "weekday",(char *) "flags", NULL
18903 };
18904
18905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18906 {
18907 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18908 if (SWIG_arg_fail(1)) SWIG_fail;
18909 }
18910 if (obj1) {
18911 {
18912 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18913 if (SWIG_arg_fail(2)) SWIG_fail;
18914 }
18915 }
18916 {
18917 PyThreadState* __tstate = wxPyBeginAllowThreads();
18918 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18919
18920 wxPyEndAllowThreads(__tstate);
18921 if (PyErr_Occurred()) SWIG_fail;
18922 }
18923 {
18924 #if wxUSE_UNICODE
18925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18926 #else
18927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18928 #endif
18929 }
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxString *arg1 = (wxString *) 0 ;
18939 wxString *arg2 = (wxString *) 0 ;
18940 bool temp1 = false ;
18941 bool temp2 = false ;
18942 PyObject * obj0 = 0 ;
18943 PyObject * obj1 = 0 ;
18944 char *kwnames[] = {
18945 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18946 };
18947
18948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18949 {
18950 arg1 = wxString_in_helper(obj0);
18951 if (arg1 == NULL) SWIG_fail;
18952 temp1 = true;
18953 }
18954 {
18955 arg2 = wxString_in_helper(obj1);
18956 if (arg2 == NULL) SWIG_fail;
18957 temp2 = true;
18958 }
18959 {
18960 PyThreadState* __tstate = wxPyBeginAllowThreads();
18961 wxDateTime::GetAmPmStrings(arg1,arg2);
18962
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 Py_INCREF(Py_None); resultobj = Py_None;
18967 {
18968 if (temp1)
18969 delete arg1;
18970 }
18971 {
18972 if (temp2)
18973 delete arg2;
18974 }
18975 return resultobj;
18976 fail:
18977 {
18978 if (temp1)
18979 delete arg1;
18980 }
18981 {
18982 if (temp2)
18983 delete arg2;
18984 }
18985 return NULL;
18986 }
18987
18988
18989 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj;
18991 int arg1 = (int) wxDateTime::Inv_Year ;
18992 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
18993 bool result;
18994 PyObject * obj0 = 0 ;
18995 PyObject * obj1 = 0 ;
18996 char *kwnames[] = {
18997 (char *) "year",(char *) "country", NULL
18998 };
18999
19000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19001 if (obj0) {
19002 {
19003 arg1 = (int)(SWIG_As_int(obj0));
19004 if (SWIG_arg_fail(1)) SWIG_fail;
19005 }
19006 }
19007 if (obj1) {
19008 {
19009 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19010 if (SWIG_arg_fail(2)) SWIG_fail;
19011 }
19012 }
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19016
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 {
19021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19022 }
19023 return resultobj;
19024 fail:
19025 return NULL;
19026 }
19027
19028
19029 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19030 PyObject *resultobj;
19031 int arg1 = (int) wxDateTime::Inv_Year ;
19032 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19033 wxDateTime result;
19034 PyObject * obj0 = 0 ;
19035 PyObject * obj1 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "year",(char *) "country", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19041 if (obj0) {
19042 {
19043 arg1 = (int)(SWIG_As_int(obj0));
19044 if (SWIG_arg_fail(1)) SWIG_fail;
19045 }
19046 }
19047 if (obj1) {
19048 {
19049 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19050 if (SWIG_arg_fail(2)) SWIG_fail;
19051 }
19052 }
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19056
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 {
19061 wxDateTime * resultptr;
19062 resultptr = new wxDateTime((wxDateTime &)(result));
19063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19064 }
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 int arg1 = (int) wxDateTime::Inv_Year ;
19074 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19075 wxDateTime result;
19076 PyObject * obj0 = 0 ;
19077 PyObject * obj1 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "year",(char *) "country", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19083 if (obj0) {
19084 {
19085 arg1 = (int)(SWIG_As_int(obj0));
19086 if (SWIG_arg_fail(1)) SWIG_fail;
19087 }
19088 }
19089 if (obj1) {
19090 {
19091 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19092 if (SWIG_arg_fail(2)) SWIG_fail;
19093 }
19094 }
19095 {
19096 PyThreadState* __tstate = wxPyBeginAllowThreads();
19097 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19098
19099 wxPyEndAllowThreads(__tstate);
19100 if (PyErr_Occurred()) SWIG_fail;
19101 }
19102 {
19103 wxDateTime * resultptr;
19104 resultptr = new wxDateTime((wxDateTime &)(result));
19105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19106 }
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj;
19115 wxDateTime result;
19116 char *kwnames[] = {
19117 NULL
19118 };
19119
19120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = wxDateTime::Now();
19124
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 wxDateTime * resultptr;
19130 resultptr = new wxDateTime((wxDateTime &)(result));
19131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19132 }
19133 return resultobj;
19134 fail:
19135 return NULL;
19136 }
19137
19138
19139 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19140 PyObject *resultobj;
19141 wxDateTime result;
19142 char *kwnames[] = {
19143 NULL
19144 };
19145
19146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19147 {
19148 PyThreadState* __tstate = wxPyBeginAllowThreads();
19149 result = wxDateTime::UNow();
19150
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 {
19155 wxDateTime * resultptr;
19156 resultptr = new wxDateTime((wxDateTime &)(result));
19157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19158 }
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj;
19167 wxDateTime result;
19168 char *kwnames[] = {
19169 NULL
19170 };
19171
19172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19173 {
19174 PyThreadState* __tstate = wxPyBeginAllowThreads();
19175 result = wxDateTime::Today();
19176
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 {
19181 wxDateTime * resultptr;
19182 resultptr = new wxDateTime((wxDateTime &)(result));
19183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19184 }
19185 return resultobj;
19186 fail:
19187 return NULL;
19188 }
19189
19190
19191 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19192 PyObject *resultobj;
19193 wxDateTime *result;
19194 char *kwnames[] = {
19195 NULL
19196 };
19197
19198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19199 {
19200 PyThreadState* __tstate = wxPyBeginAllowThreads();
19201 result = (wxDateTime *)new wxDateTime();
19202
19203 wxPyEndAllowThreads(__tstate);
19204 if (PyErr_Occurred()) SWIG_fail;
19205 }
19206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19207 return resultobj;
19208 fail:
19209 return NULL;
19210 }
19211
19212
19213 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj;
19215 time_t arg1 ;
19216 wxDateTime *result;
19217 PyObject * obj0 = 0 ;
19218 char *kwnames[] = {
19219 (char *) "timet", NULL
19220 };
19221
19222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19223 {
19224 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19225 if (SWIG_arg_fail(1)) SWIG_fail;
19226 }
19227 {
19228 PyThreadState* __tstate = wxPyBeginAllowThreads();
19229 result = (wxDateTime *)new wxDateTime(arg1);
19230
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19242 PyObject *resultobj;
19243 double arg1 ;
19244 wxDateTime *result;
19245 PyObject * obj0 = 0 ;
19246 char *kwnames[] = {
19247 (char *) "jdn", NULL
19248 };
19249
19250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19251 {
19252 arg1 = (double)(SWIG_As_double(obj0));
19253 if (SWIG_arg_fail(1)) SWIG_fail;
19254 }
19255 {
19256 PyThreadState* __tstate = wxPyBeginAllowThreads();
19257 result = (wxDateTime *)new wxDateTime(arg1);
19258
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19270 PyObject *resultobj;
19271 int arg1 ;
19272 int arg2 = (int) 0 ;
19273 int arg3 = (int) 0 ;
19274 int arg4 = (int) 0 ;
19275 wxDateTime *result;
19276 PyObject * obj0 = 0 ;
19277 PyObject * obj1 = 0 ;
19278 PyObject * obj2 = 0 ;
19279 PyObject * obj3 = 0 ;
19280 char *kwnames[] = {
19281 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19282 };
19283
19284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19285 {
19286 arg1 = (int)(SWIG_As_int(obj0));
19287 if (SWIG_arg_fail(1)) SWIG_fail;
19288 }
19289 if (obj1) {
19290 {
19291 arg2 = (int)(SWIG_As_int(obj1));
19292 if (SWIG_arg_fail(2)) SWIG_fail;
19293 }
19294 }
19295 if (obj2) {
19296 {
19297 arg3 = (int)(SWIG_As_int(obj2));
19298 if (SWIG_arg_fail(3)) SWIG_fail;
19299 }
19300 }
19301 if (obj3) {
19302 {
19303 arg4 = (int)(SWIG_As_int(obj3));
19304 if (SWIG_arg_fail(4)) SWIG_fail;
19305 }
19306 }
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19310
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19315 return resultobj;
19316 fail:
19317 return NULL;
19318 }
19319
19320
19321 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19322 PyObject *resultobj;
19323 int arg1 ;
19324 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19325 int arg3 = (int) wxDateTime::Inv_Year ;
19326 int arg4 = (int) 0 ;
19327 int arg5 = (int) 0 ;
19328 int arg6 = (int) 0 ;
19329 int arg7 = (int) 0 ;
19330 wxDateTime *result;
19331 PyObject * obj0 = 0 ;
19332 PyObject * obj1 = 0 ;
19333 PyObject * obj2 = 0 ;
19334 PyObject * obj3 = 0 ;
19335 PyObject * obj4 = 0 ;
19336 PyObject * obj5 = 0 ;
19337 PyObject * obj6 = 0 ;
19338 char *kwnames[] = {
19339 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19340 };
19341
19342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19343 {
19344 arg1 = (int)(SWIG_As_int(obj0));
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 }
19347 if (obj1) {
19348 {
19349 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19350 if (SWIG_arg_fail(2)) SWIG_fail;
19351 }
19352 }
19353 if (obj2) {
19354 {
19355 arg3 = (int)(SWIG_As_int(obj2));
19356 if (SWIG_arg_fail(3)) SWIG_fail;
19357 }
19358 }
19359 if (obj3) {
19360 {
19361 arg4 = (int)(SWIG_As_int(obj3));
19362 if (SWIG_arg_fail(4)) SWIG_fail;
19363 }
19364 }
19365 if (obj4) {
19366 {
19367 arg5 = (int)(SWIG_As_int(obj4));
19368 if (SWIG_arg_fail(5)) SWIG_fail;
19369 }
19370 }
19371 if (obj5) {
19372 {
19373 arg6 = (int)(SWIG_As_int(obj5));
19374 if (SWIG_arg_fail(6)) SWIG_fail;
19375 }
19376 }
19377 if (obj6) {
19378 {
19379 arg7 = (int)(SWIG_As_int(obj6));
19380 if (SWIG_arg_fail(7)) SWIG_fail;
19381 }
19382 }
19383 {
19384 PyThreadState* __tstate = wxPyBeginAllowThreads();
19385 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19386
19387 wxPyEndAllowThreads(__tstate);
19388 if (PyErr_Occurred()) SWIG_fail;
19389 }
19390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19398 PyObject *resultobj;
19399 wxDateTime *arg1 = (wxDateTime *) 0 ;
19400 PyObject * obj0 = 0 ;
19401 char *kwnames[] = {
19402 (char *) "self", NULL
19403 };
19404
19405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19407 if (SWIG_arg_fail(1)) SWIG_fail;
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 delete arg1;
19411
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 Py_INCREF(Py_None); resultobj = Py_None;
19416 return resultobj;
19417 fail:
19418 return NULL;
19419 }
19420
19421
19422 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19423 PyObject *resultobj;
19424 wxDateTime *arg1 = (wxDateTime *) 0 ;
19425 wxDateTime *result;
19426 PyObject * obj0 = 0 ;
19427 char *kwnames[] = {
19428 (char *) "self", NULL
19429 };
19430
19431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19433 if (SWIG_arg_fail(1)) SWIG_fail;
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 {
19437 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19438 result = (wxDateTime *) &_result_ref;
19439 }
19440
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj;
19453 wxDateTime *arg1 = (wxDateTime *) 0 ;
19454 time_t arg2 ;
19455 wxDateTime *result;
19456 PyObject * obj0 = 0 ;
19457 PyObject * obj1 = 0 ;
19458 char *kwnames[] = {
19459 (char *) "self",(char *) "timet", NULL
19460 };
19461
19462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19464 if (SWIG_arg_fail(1)) SWIG_fail;
19465 {
19466 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19467 if (SWIG_arg_fail(2)) SWIG_fail;
19468 }
19469 {
19470 PyThreadState* __tstate = wxPyBeginAllowThreads();
19471 {
19472 wxDateTime &_result_ref = (arg1)->Set(arg2);
19473 result = (wxDateTime *) &_result_ref;
19474 }
19475
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19487 PyObject *resultobj;
19488 wxDateTime *arg1 = (wxDateTime *) 0 ;
19489 double arg2 ;
19490 wxDateTime *result;
19491 PyObject * obj0 = 0 ;
19492 PyObject * obj1 = 0 ;
19493 char *kwnames[] = {
19494 (char *) "self",(char *) "jdn", NULL
19495 };
19496
19497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19499 if (SWIG_arg_fail(1)) SWIG_fail;
19500 {
19501 arg2 = (double)(SWIG_As_double(obj1));
19502 if (SWIG_arg_fail(2)) SWIG_fail;
19503 }
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 {
19507 wxDateTime &_result_ref = (arg1)->Set(arg2);
19508 result = (wxDateTime *) &_result_ref;
19509 }
19510
19511 wxPyEndAllowThreads(__tstate);
19512 if (PyErr_Occurred()) SWIG_fail;
19513 }
19514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19515 return resultobj;
19516 fail:
19517 return NULL;
19518 }
19519
19520
19521 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19522 PyObject *resultobj;
19523 wxDateTime *arg1 = (wxDateTime *) 0 ;
19524 int arg2 ;
19525 int arg3 = (int) 0 ;
19526 int arg4 = (int) 0 ;
19527 int arg5 = (int) 0 ;
19528 wxDateTime *result;
19529 PyObject * obj0 = 0 ;
19530 PyObject * obj1 = 0 ;
19531 PyObject * obj2 = 0 ;
19532 PyObject * obj3 = 0 ;
19533 PyObject * obj4 = 0 ;
19534 char *kwnames[] = {
19535 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19536 };
19537
19538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19540 if (SWIG_arg_fail(1)) SWIG_fail;
19541 {
19542 arg2 = (int)(SWIG_As_int(obj1));
19543 if (SWIG_arg_fail(2)) SWIG_fail;
19544 }
19545 if (obj2) {
19546 {
19547 arg3 = (int)(SWIG_As_int(obj2));
19548 if (SWIG_arg_fail(3)) SWIG_fail;
19549 }
19550 }
19551 if (obj3) {
19552 {
19553 arg4 = (int)(SWIG_As_int(obj3));
19554 if (SWIG_arg_fail(4)) SWIG_fail;
19555 }
19556 }
19557 if (obj4) {
19558 {
19559 arg5 = (int)(SWIG_As_int(obj4));
19560 if (SWIG_arg_fail(5)) SWIG_fail;
19561 }
19562 }
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 {
19566 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19567 result = (wxDateTime *) &_result_ref;
19568 }
19569
19570 wxPyEndAllowThreads(__tstate);
19571 if (PyErr_Occurred()) SWIG_fail;
19572 }
19573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19574 return resultobj;
19575 fail:
19576 return NULL;
19577 }
19578
19579
19580 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19581 PyObject *resultobj;
19582 wxDateTime *arg1 = (wxDateTime *) 0 ;
19583 int arg2 ;
19584 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19585 int arg4 = (int) wxDateTime::Inv_Year ;
19586 int arg5 = (int) 0 ;
19587 int arg6 = (int) 0 ;
19588 int arg7 = (int) 0 ;
19589 int arg8 = (int) 0 ;
19590 wxDateTime *result;
19591 PyObject * obj0 = 0 ;
19592 PyObject * obj1 = 0 ;
19593 PyObject * obj2 = 0 ;
19594 PyObject * obj3 = 0 ;
19595 PyObject * obj4 = 0 ;
19596 PyObject * obj5 = 0 ;
19597 PyObject * obj6 = 0 ;
19598 PyObject * obj7 = 0 ;
19599 char *kwnames[] = {
19600 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19601 };
19602
19603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19605 if (SWIG_arg_fail(1)) SWIG_fail;
19606 {
19607 arg2 = (int)(SWIG_As_int(obj1));
19608 if (SWIG_arg_fail(2)) SWIG_fail;
19609 }
19610 if (obj2) {
19611 {
19612 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19613 if (SWIG_arg_fail(3)) SWIG_fail;
19614 }
19615 }
19616 if (obj3) {
19617 {
19618 arg4 = (int)(SWIG_As_int(obj3));
19619 if (SWIG_arg_fail(4)) SWIG_fail;
19620 }
19621 }
19622 if (obj4) {
19623 {
19624 arg5 = (int)(SWIG_As_int(obj4));
19625 if (SWIG_arg_fail(5)) SWIG_fail;
19626 }
19627 }
19628 if (obj5) {
19629 {
19630 arg6 = (int)(SWIG_As_int(obj5));
19631 if (SWIG_arg_fail(6)) SWIG_fail;
19632 }
19633 }
19634 if (obj6) {
19635 {
19636 arg7 = (int)(SWIG_As_int(obj6));
19637 if (SWIG_arg_fail(7)) SWIG_fail;
19638 }
19639 }
19640 if (obj7) {
19641 {
19642 arg8 = (int)(SWIG_As_int(obj7));
19643 if (SWIG_arg_fail(8)) SWIG_fail;
19644 }
19645 }
19646 {
19647 PyThreadState* __tstate = wxPyBeginAllowThreads();
19648 {
19649 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19650 result = (wxDateTime *) &_result_ref;
19651 }
19652
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj;
19665 wxDateTime *arg1 = (wxDateTime *) 0 ;
19666 wxDateTime *result;
19667 PyObject * obj0 = 0 ;
19668 char *kwnames[] = {
19669 (char *) "self", NULL
19670 };
19671
19672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19674 if (SWIG_arg_fail(1)) SWIG_fail;
19675 {
19676 PyThreadState* __tstate = wxPyBeginAllowThreads();
19677 {
19678 wxDateTime &_result_ref = (arg1)->ResetTime();
19679 result = (wxDateTime *) &_result_ref;
19680 }
19681
19682 wxPyEndAllowThreads(__tstate);
19683 if (PyErr_Occurred()) SWIG_fail;
19684 }
19685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19686 return resultobj;
19687 fail:
19688 return NULL;
19689 }
19690
19691
19692 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19693 PyObject *resultobj;
19694 wxDateTime *arg1 = (wxDateTime *) 0 ;
19695 int arg2 ;
19696 wxDateTime *result;
19697 PyObject * obj0 = 0 ;
19698 PyObject * obj1 = 0 ;
19699 char *kwnames[] = {
19700 (char *) "self",(char *) "year", NULL
19701 };
19702
19703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19705 if (SWIG_arg_fail(1)) SWIG_fail;
19706 {
19707 arg2 = (int)(SWIG_As_int(obj1));
19708 if (SWIG_arg_fail(2)) SWIG_fail;
19709 }
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 {
19713 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19714 result = (wxDateTime *) &_result_ref;
19715 }
19716
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 wxDateTime *arg1 = (wxDateTime *) 0 ;
19730 wxDateTime::Month arg2 ;
19731 wxDateTime *result;
19732 PyObject * obj0 = 0 ;
19733 PyObject * obj1 = 0 ;
19734 char *kwnames[] = {
19735 (char *) "self",(char *) "month", NULL
19736 };
19737
19738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19740 if (SWIG_arg_fail(1)) SWIG_fail;
19741 {
19742 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19743 if (SWIG_arg_fail(2)) SWIG_fail;
19744 }
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 {
19748 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19749 result = (wxDateTime *) &_result_ref;
19750 }
19751
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19756 return resultobj;
19757 fail:
19758 return NULL;
19759 }
19760
19761
19762 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19763 PyObject *resultobj;
19764 wxDateTime *arg1 = (wxDateTime *) 0 ;
19765 int arg2 ;
19766 wxDateTime *result;
19767 PyObject * obj0 = 0 ;
19768 PyObject * obj1 = 0 ;
19769 char *kwnames[] = {
19770 (char *) "self",(char *) "day", NULL
19771 };
19772
19773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19775 if (SWIG_arg_fail(1)) SWIG_fail;
19776 {
19777 arg2 = (int)(SWIG_As_int(obj1));
19778 if (SWIG_arg_fail(2)) SWIG_fail;
19779 }
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 {
19783 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19784 result = (wxDateTime *) &_result_ref;
19785 }
19786
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19798 PyObject *resultobj;
19799 wxDateTime *arg1 = (wxDateTime *) 0 ;
19800 int arg2 ;
19801 wxDateTime *result;
19802 PyObject * obj0 = 0 ;
19803 PyObject * obj1 = 0 ;
19804 char *kwnames[] = {
19805 (char *) "self",(char *) "hour", NULL
19806 };
19807
19808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19810 if (SWIG_arg_fail(1)) SWIG_fail;
19811 {
19812 arg2 = (int)(SWIG_As_int(obj1));
19813 if (SWIG_arg_fail(2)) SWIG_fail;
19814 }
19815 {
19816 PyThreadState* __tstate = wxPyBeginAllowThreads();
19817 {
19818 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19819 result = (wxDateTime *) &_result_ref;
19820 }
19821
19822 wxPyEndAllowThreads(__tstate);
19823 if (PyErr_Occurred()) SWIG_fail;
19824 }
19825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19826 return resultobj;
19827 fail:
19828 return NULL;
19829 }
19830
19831
19832 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj;
19834 wxDateTime *arg1 = (wxDateTime *) 0 ;
19835 int arg2 ;
19836 wxDateTime *result;
19837 PyObject * obj0 = 0 ;
19838 PyObject * obj1 = 0 ;
19839 char *kwnames[] = {
19840 (char *) "self",(char *) "minute", NULL
19841 };
19842
19843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19845 if (SWIG_arg_fail(1)) SWIG_fail;
19846 {
19847 arg2 = (int)(SWIG_As_int(obj1));
19848 if (SWIG_arg_fail(2)) SWIG_fail;
19849 }
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 {
19853 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19854 result = (wxDateTime *) &_result_ref;
19855 }
19856
19857 wxPyEndAllowThreads(__tstate);
19858 if (PyErr_Occurred()) SWIG_fail;
19859 }
19860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj;
19869 wxDateTime *arg1 = (wxDateTime *) 0 ;
19870 int arg2 ;
19871 wxDateTime *result;
19872 PyObject * obj0 = 0 ;
19873 PyObject * obj1 = 0 ;
19874 char *kwnames[] = {
19875 (char *) "self",(char *) "second", NULL
19876 };
19877
19878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19880 if (SWIG_arg_fail(1)) SWIG_fail;
19881 {
19882 arg2 = (int)(SWIG_As_int(obj1));
19883 if (SWIG_arg_fail(2)) SWIG_fail;
19884 }
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 {
19888 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
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_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19903 PyObject *resultobj;
19904 wxDateTime *arg1 = (wxDateTime *) 0 ;
19905 int arg2 ;
19906 wxDateTime *result;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 char *kwnames[] = {
19910 (char *) "self",(char *) "millisecond", NULL
19911 };
19912
19913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19915 if (SWIG_arg_fail(1)) SWIG_fail;
19916 {
19917 arg2 = (int)(SWIG_As_int(obj1));
19918 if (SWIG_arg_fail(2)) SWIG_fail;
19919 }
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 {
19923 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19924 result = (wxDateTime *) &_result_ref;
19925 }
19926
19927 wxPyEndAllowThreads(__tstate);
19928 if (PyErr_Occurred()) SWIG_fail;
19929 }
19930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19931 return resultobj;
19932 fail:
19933 return NULL;
19934 }
19935
19936
19937 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19938 PyObject *resultobj;
19939 wxDateTime *arg1 = (wxDateTime *) 0 ;
19940 wxDateTime::WeekDay arg2 ;
19941 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19942 wxDateTime *result;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 PyObject * obj2 = 0 ;
19946 char *kwnames[] = {
19947 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19948 };
19949
19950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19952 if (SWIG_arg_fail(1)) SWIG_fail;
19953 {
19954 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19955 if (SWIG_arg_fail(2)) SWIG_fail;
19956 }
19957 if (obj2) {
19958 {
19959 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19960 if (SWIG_arg_fail(3)) SWIG_fail;
19961 }
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 {
19966 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19967 result = (wxDateTime *) &_result_ref;
19968 }
19969
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19974 return resultobj;
19975 fail:
19976 return NULL;
19977 }
19978
19979
19980 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19981 PyObject *resultobj;
19982 wxDateTime *arg1 = (wxDateTime *) 0 ;
19983 wxDateTime::WeekDay arg2 ;
19984 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19985 wxDateTime result;
19986 PyObject * obj0 = 0 ;
19987 PyObject * obj1 = 0 ;
19988 PyObject * obj2 = 0 ;
19989 char *kwnames[] = {
19990 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19991 };
19992
19993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19995 if (SWIG_arg_fail(1)) SWIG_fail;
19996 {
19997 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19998 if (SWIG_arg_fail(2)) SWIG_fail;
19999 }
20000 if (obj2) {
20001 {
20002 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20003 if (SWIG_arg_fail(3)) SWIG_fail;
20004 }
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 wxDateTime * resultptr;
20015 resultptr = new wxDateTime((wxDateTime &)(result));
20016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20017 }
20018 return resultobj;
20019 fail:
20020 return NULL;
20021 }
20022
20023
20024 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj;
20026 wxDateTime *arg1 = (wxDateTime *) 0 ;
20027 wxDateTime::WeekDay arg2 ;
20028 wxDateTime *result;
20029 PyObject * obj0 = 0 ;
20030 PyObject * obj1 = 0 ;
20031 char *kwnames[] = {
20032 (char *) "self",(char *) "weekday", NULL
20033 };
20034
20035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20037 if (SWIG_arg_fail(1)) SWIG_fail;
20038 {
20039 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20040 if (SWIG_arg_fail(2)) SWIG_fail;
20041 }
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 {
20045 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20046 result = (wxDateTime *) &_result_ref;
20047 }
20048
20049 wxPyEndAllowThreads(__tstate);
20050 if (PyErr_Occurred()) SWIG_fail;
20051 }
20052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20060 PyObject *resultobj;
20061 wxDateTime *arg1 = (wxDateTime *) 0 ;
20062 wxDateTime::WeekDay arg2 ;
20063 wxDateTime result;
20064 PyObject * obj0 = 0 ;
20065 PyObject * obj1 = 0 ;
20066 char *kwnames[] = {
20067 (char *) "self",(char *) "weekday", NULL
20068 };
20069
20070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20072 if (SWIG_arg_fail(1)) SWIG_fail;
20073 {
20074 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20075 if (SWIG_arg_fail(2)) SWIG_fail;
20076 }
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20080
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 {
20085 wxDateTime * resultptr;
20086 resultptr = new wxDateTime((wxDateTime &)(result));
20087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20088 }
20089 return resultobj;
20090 fail:
20091 return NULL;
20092 }
20093
20094
20095 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 wxDateTime *arg1 = (wxDateTime *) 0 ;
20098 wxDateTime::WeekDay arg2 ;
20099 wxDateTime *result;
20100 PyObject * obj0 = 0 ;
20101 PyObject * obj1 = 0 ;
20102 char *kwnames[] = {
20103 (char *) "self",(char *) "weekday", NULL
20104 };
20105
20106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 {
20110 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20111 if (SWIG_arg_fail(2)) SWIG_fail;
20112 }
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 {
20116 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20117 result = (wxDateTime *) &_result_ref;
20118 }
20119
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj;
20132 wxDateTime *arg1 = (wxDateTime *) 0 ;
20133 wxDateTime::WeekDay arg2 ;
20134 wxDateTime result;
20135 PyObject * obj0 = 0 ;
20136 PyObject * obj1 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "self",(char *) "weekday", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20143 if (SWIG_arg_fail(1)) SWIG_fail;
20144 {
20145 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20146 if (SWIG_arg_fail(2)) SWIG_fail;
20147 }
20148 {
20149 PyThreadState* __tstate = wxPyBeginAllowThreads();
20150 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20151
20152 wxPyEndAllowThreads(__tstate);
20153 if (PyErr_Occurred()) SWIG_fail;
20154 }
20155 {
20156 wxDateTime * resultptr;
20157 resultptr = new wxDateTime((wxDateTime &)(result));
20158 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20159 }
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj;
20168 wxDateTime *arg1 = (wxDateTime *) 0 ;
20169 wxDateTime::WeekDay arg2 ;
20170 int arg3 = (int) 1 ;
20171 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20172 int arg5 = (int) wxDateTime::Inv_Year ;
20173 bool result;
20174 PyObject * obj0 = 0 ;
20175 PyObject * obj1 = 0 ;
20176 PyObject * obj2 = 0 ;
20177 PyObject * obj3 = 0 ;
20178 PyObject * obj4 = 0 ;
20179 char *kwnames[] = {
20180 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20181 };
20182
20183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20185 if (SWIG_arg_fail(1)) SWIG_fail;
20186 {
20187 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20188 if (SWIG_arg_fail(2)) SWIG_fail;
20189 }
20190 if (obj2) {
20191 {
20192 arg3 = (int)(SWIG_As_int(obj2));
20193 if (SWIG_arg_fail(3)) SWIG_fail;
20194 }
20195 }
20196 if (obj3) {
20197 {
20198 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20199 if (SWIG_arg_fail(4)) SWIG_fail;
20200 }
20201 }
20202 if (obj4) {
20203 {
20204 arg5 = (int)(SWIG_As_int(obj4));
20205 if (SWIG_arg_fail(5)) SWIG_fail;
20206 }
20207 }
20208 {
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20211
20212 wxPyEndAllowThreads(__tstate);
20213 if (PyErr_Occurred()) SWIG_fail;
20214 }
20215 {
20216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20217 }
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20225 PyObject *resultobj;
20226 wxDateTime *arg1 = (wxDateTime *) 0 ;
20227 wxDateTime::WeekDay arg2 ;
20228 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20229 int arg4 = (int) wxDateTime::Inv_Year ;
20230 bool result;
20231 PyObject * obj0 = 0 ;
20232 PyObject * obj1 = 0 ;
20233 PyObject * obj2 = 0 ;
20234 PyObject * obj3 = 0 ;
20235 char *kwnames[] = {
20236 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20237 };
20238
20239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20241 if (SWIG_arg_fail(1)) SWIG_fail;
20242 {
20243 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20244 if (SWIG_arg_fail(2)) SWIG_fail;
20245 }
20246 if (obj2) {
20247 {
20248 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20249 if (SWIG_arg_fail(3)) SWIG_fail;
20250 }
20251 }
20252 if (obj3) {
20253 {
20254 arg4 = (int)(SWIG_As_int(obj3));
20255 if (SWIG_arg_fail(4)) SWIG_fail;
20256 }
20257 }
20258 {
20259 PyThreadState* __tstate = wxPyBeginAllowThreads();
20260 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20261
20262 wxPyEndAllowThreads(__tstate);
20263 if (PyErr_Occurred()) SWIG_fail;
20264 }
20265 {
20266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20267 }
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20275 PyObject *resultobj;
20276 wxDateTime *arg1 = (wxDateTime *) 0 ;
20277 wxDateTime::WeekDay arg2 ;
20278 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20279 int arg4 = (int) wxDateTime::Inv_Year ;
20280 wxDateTime result;
20281 PyObject * obj0 = 0 ;
20282 PyObject * obj1 = 0 ;
20283 PyObject * obj2 = 0 ;
20284 PyObject * obj3 = 0 ;
20285 char *kwnames[] = {
20286 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20287 };
20288
20289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20291 if (SWIG_arg_fail(1)) SWIG_fail;
20292 {
20293 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20294 if (SWIG_arg_fail(2)) SWIG_fail;
20295 }
20296 if (obj2) {
20297 {
20298 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20299 if (SWIG_arg_fail(3)) SWIG_fail;
20300 }
20301 }
20302 if (obj3) {
20303 {
20304 arg4 = (int)(SWIG_As_int(obj3));
20305 if (SWIG_arg_fail(4)) SWIG_fail;
20306 }
20307 }
20308 {
20309 PyThreadState* __tstate = wxPyBeginAllowThreads();
20310 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20311
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 {
20316 wxDateTime * resultptr;
20317 resultptr = new wxDateTime((wxDateTime &)(result));
20318 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20319 }
20320 return resultobj;
20321 fail:
20322 return NULL;
20323 }
20324
20325
20326 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20327 PyObject *resultobj;
20328 wxDateTime *arg1 = (wxDateTime *) 0 ;
20329 int arg2 ;
20330 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20331 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20332 bool result;
20333 PyObject * obj0 = 0 ;
20334 PyObject * obj1 = 0 ;
20335 PyObject * obj2 = 0 ;
20336 PyObject * obj3 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 {
20345 arg2 = (int)(SWIG_As_int(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 if (obj2) {
20349 {
20350 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20351 if (SWIG_arg_fail(3)) SWIG_fail;
20352 }
20353 }
20354 if (obj3) {
20355 {
20356 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20357 if (SWIG_arg_fail(4)) SWIG_fail;
20358 }
20359 }
20360 {
20361 PyThreadState* __tstate = wxPyBeginAllowThreads();
20362 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20363
20364 wxPyEndAllowThreads(__tstate);
20365 if (PyErr_Occurred()) SWIG_fail;
20366 }
20367 {
20368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20369 }
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20377 PyObject *resultobj;
20378 wxDateTime *arg1 = (wxDateTime *) 0 ;
20379 int arg2 ;
20380 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20381 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20382 wxDateTime result;
20383 PyObject * obj0 = 0 ;
20384 PyObject * obj1 = 0 ;
20385 PyObject * obj2 = 0 ;
20386 PyObject * obj3 = 0 ;
20387 char *kwnames[] = {
20388 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20389 };
20390
20391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20393 if (SWIG_arg_fail(1)) SWIG_fail;
20394 {
20395 arg2 = (int)(SWIG_As_int(obj1));
20396 if (SWIG_arg_fail(2)) SWIG_fail;
20397 }
20398 if (obj2) {
20399 {
20400 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20401 if (SWIG_arg_fail(3)) SWIG_fail;
20402 }
20403 }
20404 if (obj3) {
20405 {
20406 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20407 if (SWIG_arg_fail(4)) SWIG_fail;
20408 }
20409 }
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 wxDateTime * resultptr;
20419 resultptr = new wxDateTime((wxDateTime &)(result));
20420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj;
20430 int arg1 ;
20431 int arg2 ;
20432 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20433 wxDateTime result;
20434 PyObject * obj0 = 0 ;
20435 PyObject * obj1 = 0 ;
20436 PyObject * obj2 = 0 ;
20437 char *kwnames[] = {
20438 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20439 };
20440
20441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20442 {
20443 arg1 = (int)(SWIG_As_int(obj0));
20444 if (SWIG_arg_fail(1)) SWIG_fail;
20445 }
20446 {
20447 arg2 = (int)(SWIG_As_int(obj1));
20448 if (SWIG_arg_fail(2)) SWIG_fail;
20449 }
20450 if (obj2) {
20451 {
20452 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20453 if (SWIG_arg_fail(3)) SWIG_fail;
20454 }
20455 }
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 {
20464 wxDateTime * resultptr;
20465 resultptr = new wxDateTime((wxDateTime &)(result));
20466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20467 }
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 wxDateTime *arg1 = (wxDateTime *) 0 ;
20477 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20478 int arg3 = (int) wxDateTime::Inv_Year ;
20479 wxDateTime *result;
20480 PyObject * obj0 = 0 ;
20481 PyObject * obj1 = 0 ;
20482 PyObject * obj2 = 0 ;
20483 char *kwnames[] = {
20484 (char *) "self",(char *) "month",(char *) "year", NULL
20485 };
20486
20487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20489 if (SWIG_arg_fail(1)) SWIG_fail;
20490 if (obj1) {
20491 {
20492 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20493 if (SWIG_arg_fail(2)) SWIG_fail;
20494 }
20495 }
20496 if (obj2) {
20497 {
20498 arg3 = (int)(SWIG_As_int(obj2));
20499 if (SWIG_arg_fail(3)) SWIG_fail;
20500 }
20501 }
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 {
20505 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20506 result = (wxDateTime *) &_result_ref;
20507 }
20508
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj;
20521 wxDateTime *arg1 = (wxDateTime *) 0 ;
20522 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20523 int arg3 = (int) wxDateTime::Inv_Year ;
20524 wxDateTime result;
20525 PyObject * obj0 = 0 ;
20526 PyObject * obj1 = 0 ;
20527 PyObject * obj2 = 0 ;
20528 char *kwnames[] = {
20529 (char *) "self",(char *) "month",(char *) "year", NULL
20530 };
20531
20532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20534 if (SWIG_arg_fail(1)) SWIG_fail;
20535 if (obj1) {
20536 {
20537 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20538 if (SWIG_arg_fail(2)) SWIG_fail;
20539 }
20540 }
20541 if (obj2) {
20542 {
20543 arg3 = (int)(SWIG_As_int(obj2));
20544 if (SWIG_arg_fail(3)) SWIG_fail;
20545 }
20546 }
20547 {
20548 PyThreadState* __tstate = wxPyBeginAllowThreads();
20549 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20550
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 {
20555 wxDateTime * resultptr;
20556 resultptr = new wxDateTime((wxDateTime &)(result));
20557 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj;
20567 wxDateTime *arg1 = (wxDateTime *) 0 ;
20568 int arg2 ;
20569 wxDateTime *result;
20570 PyObject * obj0 = 0 ;
20571 PyObject * obj1 = 0 ;
20572 char *kwnames[] = {
20573 (char *) "self",(char *) "yday", NULL
20574 };
20575
20576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20578 if (SWIG_arg_fail(1)) SWIG_fail;
20579 {
20580 arg2 = (int)(SWIG_As_int(obj1));
20581 if (SWIG_arg_fail(2)) SWIG_fail;
20582 }
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 {
20586 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20587 result = (wxDateTime *) &_result_ref;
20588 }
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20601 PyObject *resultobj;
20602 wxDateTime *arg1 = (wxDateTime *) 0 ;
20603 int arg2 ;
20604 wxDateTime result;
20605 PyObject * obj0 = 0 ;
20606 PyObject * obj1 = 0 ;
20607 char *kwnames[] = {
20608 (char *) "self",(char *) "yday", NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20613 if (SWIG_arg_fail(1)) SWIG_fail;
20614 {
20615 arg2 = (int)(SWIG_As_int(obj1));
20616 if (SWIG_arg_fail(2)) SWIG_fail;
20617 }
20618 {
20619 PyThreadState* __tstate = wxPyBeginAllowThreads();
20620 result = (arg1)->GetYearDay(arg2);
20621
20622 wxPyEndAllowThreads(__tstate);
20623 if (PyErr_Occurred()) SWIG_fail;
20624 }
20625 {
20626 wxDateTime * resultptr;
20627 resultptr = new wxDateTime((wxDateTime &)(result));
20628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20629 }
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj;
20638 wxDateTime *arg1 = (wxDateTime *) 0 ;
20639 double result;
20640 PyObject * obj0 = 0 ;
20641 char *kwnames[] = {
20642 (char *) "self", NULL
20643 };
20644
20645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20647 if (SWIG_arg_fail(1)) SWIG_fail;
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (double)(arg1)->GetJulianDayNumber();
20651
20652 wxPyEndAllowThreads(__tstate);
20653 if (PyErr_Occurred()) SWIG_fail;
20654 }
20655 {
20656 resultobj = SWIG_From_double((double)(result));
20657 }
20658 return resultobj;
20659 fail:
20660 return NULL;
20661 }
20662
20663
20664 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20665 PyObject *resultobj;
20666 wxDateTime *arg1 = (wxDateTime *) 0 ;
20667 double result;
20668 PyObject * obj0 = 0 ;
20669 char *kwnames[] = {
20670 (char *) "self", NULL
20671 };
20672
20673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20675 if (SWIG_arg_fail(1)) SWIG_fail;
20676 {
20677 PyThreadState* __tstate = wxPyBeginAllowThreads();
20678 result = (double)(arg1)->GetJDN();
20679
20680 wxPyEndAllowThreads(__tstate);
20681 if (PyErr_Occurred()) SWIG_fail;
20682 }
20683 {
20684 resultobj = SWIG_From_double((double)(result));
20685 }
20686 return resultobj;
20687 fail:
20688 return NULL;
20689 }
20690
20691
20692 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20693 PyObject *resultobj;
20694 wxDateTime *arg1 = (wxDateTime *) 0 ;
20695 double result;
20696 PyObject * obj0 = 0 ;
20697 char *kwnames[] = {
20698 (char *) "self", NULL
20699 };
20700
20701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20703 if (SWIG_arg_fail(1)) SWIG_fail;
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20707
20708 wxPyEndAllowThreads(__tstate);
20709 if (PyErr_Occurred()) SWIG_fail;
20710 }
20711 {
20712 resultobj = SWIG_From_double((double)(result));
20713 }
20714 return resultobj;
20715 fail:
20716 return NULL;
20717 }
20718
20719
20720 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20721 PyObject *resultobj;
20722 wxDateTime *arg1 = (wxDateTime *) 0 ;
20723 double result;
20724 PyObject * obj0 = 0 ;
20725 char *kwnames[] = {
20726 (char *) "self", NULL
20727 };
20728
20729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20731 if (SWIG_arg_fail(1)) SWIG_fail;
20732 {
20733 PyThreadState* __tstate = wxPyBeginAllowThreads();
20734 result = (double)(arg1)->GetMJD();
20735
20736 wxPyEndAllowThreads(__tstate);
20737 if (PyErr_Occurred()) SWIG_fail;
20738 }
20739 {
20740 resultobj = SWIG_From_double((double)(result));
20741 }
20742 return resultobj;
20743 fail:
20744 return NULL;
20745 }
20746
20747
20748 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20749 PyObject *resultobj;
20750 wxDateTime *arg1 = (wxDateTime *) 0 ;
20751 double result;
20752 PyObject * obj0 = 0 ;
20753 char *kwnames[] = {
20754 (char *) "self", NULL
20755 };
20756
20757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20759 if (SWIG_arg_fail(1)) SWIG_fail;
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (double)(arg1)->GetRataDie();
20763
20764 wxPyEndAllowThreads(__tstate);
20765 if (PyErr_Occurred()) SWIG_fail;
20766 }
20767 {
20768 resultobj = SWIG_From_double((double)(result));
20769 }
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20777 PyObject *resultobj;
20778 wxDateTime *arg1 = (wxDateTime *) 0 ;
20779 wxDateTime::TimeZone *arg2 = 0 ;
20780 bool arg3 = (bool) false ;
20781 wxDateTime result;
20782 bool temp2 = false ;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 PyObject * obj2 = 0 ;
20786 char *kwnames[] = {
20787 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20788 };
20789
20790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 {
20794 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20795 temp2 = true;
20796 }
20797 if (obj2) {
20798 {
20799 arg3 = (bool)(SWIG_As_bool(obj2));
20800 if (SWIG_arg_fail(3)) SWIG_fail;
20801 }
20802 }
20803 {
20804 PyThreadState* __tstate = wxPyBeginAllowThreads();
20805 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20806
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 {
20811 wxDateTime * resultptr;
20812 resultptr = new wxDateTime((wxDateTime &)(result));
20813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20814 }
20815 {
20816 if (temp2) delete arg2;
20817 }
20818 return resultobj;
20819 fail:
20820 {
20821 if (temp2) delete arg2;
20822 }
20823 return NULL;
20824 }
20825
20826
20827 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20828 PyObject *resultobj;
20829 wxDateTime *arg1 = (wxDateTime *) 0 ;
20830 wxDateTime::TimeZone *arg2 = 0 ;
20831 bool arg3 = (bool) false ;
20832 wxDateTime *result;
20833 bool temp2 = false ;
20834 PyObject * obj0 = 0 ;
20835 PyObject * obj1 = 0 ;
20836 PyObject * obj2 = 0 ;
20837 char *kwnames[] = {
20838 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20839 };
20840
20841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20843 if (SWIG_arg_fail(1)) SWIG_fail;
20844 {
20845 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20846 temp2 = true;
20847 }
20848 if (obj2) {
20849 {
20850 arg3 = (bool)(SWIG_As_bool(obj2));
20851 if (SWIG_arg_fail(3)) SWIG_fail;
20852 }
20853 }
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 {
20857 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20858 result = (wxDateTime *) &_result_ref;
20859 }
20860
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20865 {
20866 if (temp2) delete arg2;
20867 }
20868 return resultobj;
20869 fail:
20870 {
20871 if (temp2) delete arg2;
20872 }
20873 return NULL;
20874 }
20875
20876
20877 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20878 PyObject *resultobj;
20879 wxDateTime *arg1 = (wxDateTime *) 0 ;
20880 bool arg2 = (bool) false ;
20881 wxDateTime result;
20882 PyObject * obj0 = 0 ;
20883 PyObject * obj1 = 0 ;
20884 char *kwnames[] = {
20885 (char *) "self",(char *) "noDST", NULL
20886 };
20887
20888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20890 if (SWIG_arg_fail(1)) SWIG_fail;
20891 if (obj1) {
20892 {
20893 arg2 = (bool)(SWIG_As_bool(obj1));
20894 if (SWIG_arg_fail(2)) SWIG_fail;
20895 }
20896 }
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (arg1)->ToGMT(arg2);
20900
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 {
20905 wxDateTime * resultptr;
20906 resultptr = new wxDateTime((wxDateTime &)(result));
20907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20908 }
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20916 PyObject *resultobj;
20917 wxDateTime *arg1 = (wxDateTime *) 0 ;
20918 bool arg2 = (bool) false ;
20919 wxDateTime *result;
20920 PyObject * obj0 = 0 ;
20921 PyObject * obj1 = 0 ;
20922 char *kwnames[] = {
20923 (char *) "self",(char *) "noDST", NULL
20924 };
20925
20926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20928 if (SWIG_arg_fail(1)) SWIG_fail;
20929 if (obj1) {
20930 {
20931 arg2 = (bool)(SWIG_As_bool(obj1));
20932 if (SWIG_arg_fail(2)) SWIG_fail;
20933 }
20934 }
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 {
20938 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20939 result = (wxDateTime *) &_result_ref;
20940 }
20941
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20953 PyObject *resultobj;
20954 wxDateTime *arg1 = (wxDateTime *) 0 ;
20955 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20956 int result;
20957 PyObject * obj0 = 0 ;
20958 PyObject * obj1 = 0 ;
20959 char *kwnames[] = {
20960 (char *) "self",(char *) "country", NULL
20961 };
20962
20963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20965 if (SWIG_arg_fail(1)) SWIG_fail;
20966 if (obj1) {
20967 {
20968 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20969 if (SWIG_arg_fail(2)) SWIG_fail;
20970 }
20971 }
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20975
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 {
20980 resultobj = SWIG_From_int((int)(result));
20981 }
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
20989 PyObject *resultobj;
20990 wxDateTime *arg1 = (wxDateTime *) 0 ;
20991 bool result;
20992 PyObject * obj0 = 0 ;
20993 char *kwnames[] = {
20994 (char *) "self", NULL
20995 };
20996
20997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
20998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20999 if (SWIG_arg_fail(1)) SWIG_fail;
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 result = (bool)((wxDateTime const *)arg1)->IsValid();
21003
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 {
21008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21009 }
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj;
21018 wxDateTime *arg1 = (wxDateTime *) 0 ;
21019 time_t result;
21020 PyObject * obj0 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "self", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21027 if (SWIG_arg_fail(1)) SWIG_fail;
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21031
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 {
21036 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21037 }
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21045 PyObject *resultobj;
21046 wxDateTime *arg1 = (wxDateTime *) 0 ;
21047 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21048 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21049 int result;
21050 bool temp2 = false ;
21051 PyObject * obj0 = 0 ;
21052 PyObject * obj1 = 0 ;
21053 char *kwnames[] = {
21054 (char *) "self",(char *) "tz", NULL
21055 };
21056
21057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21059 if (SWIG_arg_fail(1)) SWIG_fail;
21060 if (obj1) {
21061 {
21062 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21063 temp2 = true;
21064 }
21065 }
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 resultobj = SWIG_From_int((int)(result));
21075 }
21076 {
21077 if (temp2) delete arg2;
21078 }
21079 return resultobj;
21080 fail:
21081 {
21082 if (temp2) delete arg2;
21083 }
21084 return NULL;
21085 }
21086
21087
21088 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21089 PyObject *resultobj;
21090 wxDateTime *arg1 = (wxDateTime *) 0 ;
21091 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21092 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21093 wxDateTime::Month result;
21094 bool temp2 = false ;
21095 PyObject * obj0 = 0 ;
21096 PyObject * obj1 = 0 ;
21097 char *kwnames[] = {
21098 (char *) "self",(char *) "tz", NULL
21099 };
21100
21101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21103 if (SWIG_arg_fail(1)) SWIG_fail;
21104 if (obj1) {
21105 {
21106 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21107 temp2 = true;
21108 }
21109 }
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21113
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 resultobj = SWIG_From_int((result));
21118 {
21119 if (temp2) delete arg2;
21120 }
21121 return resultobj;
21122 fail:
21123 {
21124 if (temp2) delete arg2;
21125 }
21126 return NULL;
21127 }
21128
21129
21130 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21131 PyObject *resultobj;
21132 wxDateTime *arg1 = (wxDateTime *) 0 ;
21133 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21134 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21135 int result;
21136 bool temp2 = false ;
21137 PyObject * obj0 = 0 ;
21138 PyObject * obj1 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self",(char *) "tz", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 if (obj1) {
21147 {
21148 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21149 temp2 = true;
21150 }
21151 }
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21155
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 {
21160 resultobj = SWIG_From_int((int)(result));
21161 }
21162 {
21163 if (temp2) delete arg2;
21164 }
21165 return resultobj;
21166 fail:
21167 {
21168 if (temp2) delete arg2;
21169 }
21170 return NULL;
21171 }
21172
21173
21174 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21175 PyObject *resultobj;
21176 wxDateTime *arg1 = (wxDateTime *) 0 ;
21177 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21178 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21179 wxDateTime::WeekDay result;
21180 bool temp2 = false ;
21181 PyObject * obj0 = 0 ;
21182 PyObject * obj1 = 0 ;
21183 char *kwnames[] = {
21184 (char *) "self",(char *) "tz", NULL
21185 };
21186
21187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21189 if (SWIG_arg_fail(1)) SWIG_fail;
21190 if (obj1) {
21191 {
21192 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21193 temp2 = true;
21194 }
21195 }
21196 {
21197 PyThreadState* __tstate = wxPyBeginAllowThreads();
21198 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21199
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 resultobj = SWIG_From_int((result));
21204 {
21205 if (temp2) delete arg2;
21206 }
21207 return resultobj;
21208 fail:
21209 {
21210 if (temp2) delete arg2;
21211 }
21212 return NULL;
21213 }
21214
21215
21216 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21217 PyObject *resultobj;
21218 wxDateTime *arg1 = (wxDateTime *) 0 ;
21219 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21220 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21221 int result;
21222 bool temp2 = false ;
21223 PyObject * obj0 = 0 ;
21224 PyObject * obj1 = 0 ;
21225 char *kwnames[] = {
21226 (char *) "self",(char *) "tz", NULL
21227 };
21228
21229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21231 if (SWIG_arg_fail(1)) SWIG_fail;
21232 if (obj1) {
21233 {
21234 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21235 temp2 = true;
21236 }
21237 }
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21241
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 {
21246 resultobj = SWIG_From_int((int)(result));
21247 }
21248 {
21249 if (temp2) delete arg2;
21250 }
21251 return resultobj;
21252 fail:
21253 {
21254 if (temp2) delete arg2;
21255 }
21256 return NULL;
21257 }
21258
21259
21260 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21261 PyObject *resultobj;
21262 wxDateTime *arg1 = (wxDateTime *) 0 ;
21263 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21264 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21265 int result;
21266 bool temp2 = false ;
21267 PyObject * obj0 = 0 ;
21268 PyObject * obj1 = 0 ;
21269 char *kwnames[] = {
21270 (char *) "self",(char *) "tz", NULL
21271 };
21272
21273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21275 if (SWIG_arg_fail(1)) SWIG_fail;
21276 if (obj1) {
21277 {
21278 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21279 temp2 = true;
21280 }
21281 }
21282 {
21283 PyThreadState* __tstate = wxPyBeginAllowThreads();
21284 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21285
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 {
21290 resultobj = SWIG_From_int((int)(result));
21291 }
21292 {
21293 if (temp2) delete arg2;
21294 }
21295 return resultobj;
21296 fail:
21297 {
21298 if (temp2) delete arg2;
21299 }
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj;
21306 wxDateTime *arg1 = (wxDateTime *) 0 ;
21307 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21308 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21309 int result;
21310 bool temp2 = false ;
21311 PyObject * obj0 = 0 ;
21312 PyObject * obj1 = 0 ;
21313 char *kwnames[] = {
21314 (char *) "self",(char *) "tz", NULL
21315 };
21316
21317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21319 if (SWIG_arg_fail(1)) SWIG_fail;
21320 if (obj1) {
21321 {
21322 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21323 temp2 = true;
21324 }
21325 }
21326 {
21327 PyThreadState* __tstate = wxPyBeginAllowThreads();
21328 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21329
21330 wxPyEndAllowThreads(__tstate);
21331 if (PyErr_Occurred()) SWIG_fail;
21332 }
21333 {
21334 resultobj = SWIG_From_int((int)(result));
21335 }
21336 {
21337 if (temp2) delete arg2;
21338 }
21339 return resultobj;
21340 fail:
21341 {
21342 if (temp2) delete arg2;
21343 }
21344 return NULL;
21345 }
21346
21347
21348 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21349 PyObject *resultobj;
21350 wxDateTime *arg1 = (wxDateTime *) 0 ;
21351 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21352 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21353 int result;
21354 bool temp2 = false ;
21355 PyObject * obj0 = 0 ;
21356 PyObject * obj1 = 0 ;
21357 char *kwnames[] = {
21358 (char *) "self",(char *) "tz", NULL
21359 };
21360
21361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21363 if (SWIG_arg_fail(1)) SWIG_fail;
21364 if (obj1) {
21365 {
21366 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21367 temp2 = true;
21368 }
21369 }
21370 {
21371 PyThreadState* __tstate = wxPyBeginAllowThreads();
21372 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21373
21374 wxPyEndAllowThreads(__tstate);
21375 if (PyErr_Occurred()) SWIG_fail;
21376 }
21377 {
21378 resultobj = SWIG_From_int((int)(result));
21379 }
21380 {
21381 if (temp2) delete arg2;
21382 }
21383 return resultobj;
21384 fail:
21385 {
21386 if (temp2) delete arg2;
21387 }
21388 return NULL;
21389 }
21390
21391
21392 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21393 PyObject *resultobj;
21394 wxDateTime *arg1 = (wxDateTime *) 0 ;
21395 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21396 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21397 int result;
21398 bool temp2 = false ;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char *kwnames[] = {
21402 (char *) "self",(char *) "tz", NULL
21403 };
21404
21405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21407 if (SWIG_arg_fail(1)) SWIG_fail;
21408 if (obj1) {
21409 {
21410 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21411 temp2 = true;
21412 }
21413 }
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21417
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 {
21422 resultobj = SWIG_From_int((int)(result));
21423 }
21424 {
21425 if (temp2) delete arg2;
21426 }
21427 return resultobj;
21428 fail:
21429 {
21430 if (temp2) delete arg2;
21431 }
21432 return NULL;
21433 }
21434
21435
21436 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21437 PyObject *resultobj;
21438 wxDateTime *arg1 = (wxDateTime *) 0 ;
21439 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21440 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21441 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21442 int result;
21443 bool temp3 = false ;
21444 PyObject * obj0 = 0 ;
21445 PyObject * obj1 = 0 ;
21446 PyObject * obj2 = 0 ;
21447 char *kwnames[] = {
21448 (char *) "self",(char *) "flags",(char *) "tz", NULL
21449 };
21450
21451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21453 if (SWIG_arg_fail(1)) SWIG_fail;
21454 if (obj1) {
21455 {
21456 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21457 if (SWIG_arg_fail(2)) SWIG_fail;
21458 }
21459 }
21460 if (obj2) {
21461 {
21462 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21463 temp3 = true;
21464 }
21465 }
21466 {
21467 PyThreadState* __tstate = wxPyBeginAllowThreads();
21468 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21469
21470 wxPyEndAllowThreads(__tstate);
21471 if (PyErr_Occurred()) SWIG_fail;
21472 }
21473 {
21474 resultobj = SWIG_From_int((int)(result));
21475 }
21476 {
21477 if (temp3) delete arg3;
21478 }
21479 return resultobj;
21480 fail:
21481 {
21482 if (temp3) delete arg3;
21483 }
21484 return NULL;
21485 }
21486
21487
21488 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21489 PyObject *resultobj;
21490 wxDateTime *arg1 = (wxDateTime *) 0 ;
21491 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21492 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21493 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21494 int result;
21495 bool temp3 = false ;
21496 PyObject * obj0 = 0 ;
21497 PyObject * obj1 = 0 ;
21498 PyObject * obj2 = 0 ;
21499 char *kwnames[] = {
21500 (char *) "self",(char *) "flags",(char *) "tz", NULL
21501 };
21502
21503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21505 if (SWIG_arg_fail(1)) SWIG_fail;
21506 if (obj1) {
21507 {
21508 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21509 if (SWIG_arg_fail(2)) SWIG_fail;
21510 }
21511 }
21512 if (obj2) {
21513 {
21514 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21515 temp3 = true;
21516 }
21517 }
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 {
21526 resultobj = SWIG_From_int((int)(result));
21527 }
21528 {
21529 if (temp3) delete arg3;
21530 }
21531 return resultobj;
21532 fail:
21533 {
21534 if (temp3) delete arg3;
21535 }
21536 return NULL;
21537 }
21538
21539
21540 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21541 PyObject *resultobj;
21542 wxDateTime *arg1 = (wxDateTime *) 0 ;
21543 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21544 bool result;
21545 PyObject * obj0 = 0 ;
21546 PyObject * obj1 = 0 ;
21547 char *kwnames[] = {
21548 (char *) "self",(char *) "country", NULL
21549 };
21550
21551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21553 if (SWIG_arg_fail(1)) SWIG_fail;
21554 if (obj1) {
21555 {
21556 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21557 if (SWIG_arg_fail(2)) SWIG_fail;
21558 }
21559 }
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21563
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 {
21568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21569 }
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj;
21578 wxDateTime *arg1 = (wxDateTime *) 0 ;
21579 wxDateTime *arg2 = 0 ;
21580 bool result;
21581 PyObject * obj0 = 0 ;
21582 PyObject * obj1 = 0 ;
21583 char *kwnames[] = {
21584 (char *) "self",(char *) "datetime", NULL
21585 };
21586
21587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21589 if (SWIG_arg_fail(1)) SWIG_fail;
21590 {
21591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21592 if (SWIG_arg_fail(2)) SWIG_fail;
21593 if (arg2 == NULL) {
21594 SWIG_null_ref("wxDateTime");
21595 }
21596 if (SWIG_arg_fail(2)) SWIG_fail;
21597 }
21598 {
21599 PyThreadState* __tstate = wxPyBeginAllowThreads();
21600 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21601
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 {
21606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21607 }
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21615 PyObject *resultobj;
21616 wxDateTime *arg1 = (wxDateTime *) 0 ;
21617 wxDateTime *arg2 = 0 ;
21618 bool result;
21619 PyObject * obj0 = 0 ;
21620 PyObject * obj1 = 0 ;
21621 char *kwnames[] = {
21622 (char *) "self",(char *) "datetime", NULL
21623 };
21624
21625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21627 if (SWIG_arg_fail(1)) SWIG_fail;
21628 {
21629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21630 if (SWIG_arg_fail(2)) SWIG_fail;
21631 if (arg2 == NULL) {
21632 SWIG_null_ref("wxDateTime");
21633 }
21634 if (SWIG_arg_fail(2)) SWIG_fail;
21635 }
21636 {
21637 PyThreadState* __tstate = wxPyBeginAllowThreads();
21638 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21639
21640 wxPyEndAllowThreads(__tstate);
21641 if (PyErr_Occurred()) SWIG_fail;
21642 }
21643 {
21644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21645 }
21646 return resultobj;
21647 fail:
21648 return NULL;
21649 }
21650
21651
21652 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21653 PyObject *resultobj;
21654 wxDateTime *arg1 = (wxDateTime *) 0 ;
21655 wxDateTime *arg2 = 0 ;
21656 bool result;
21657 PyObject * obj0 = 0 ;
21658 PyObject * obj1 = 0 ;
21659 char *kwnames[] = {
21660 (char *) "self",(char *) "datetime", NULL
21661 };
21662
21663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21665 if (SWIG_arg_fail(1)) SWIG_fail;
21666 {
21667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21668 if (SWIG_arg_fail(2)) SWIG_fail;
21669 if (arg2 == NULL) {
21670 SWIG_null_ref("wxDateTime");
21671 }
21672 if (SWIG_arg_fail(2)) SWIG_fail;
21673 }
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21677
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 {
21682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21683 }
21684 return resultobj;
21685 fail:
21686 return NULL;
21687 }
21688
21689
21690 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21691 PyObject *resultobj;
21692 wxDateTime *arg1 = (wxDateTime *) 0 ;
21693 wxDateTime *arg2 = 0 ;
21694 wxDateTime *arg3 = 0 ;
21695 bool result;
21696 PyObject * obj0 = 0 ;
21697 PyObject * obj1 = 0 ;
21698 PyObject * obj2 = 0 ;
21699 char *kwnames[] = {
21700 (char *) "self",(char *) "t1",(char *) "t2", NULL
21701 };
21702
21703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21705 if (SWIG_arg_fail(1)) SWIG_fail;
21706 {
21707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21708 if (SWIG_arg_fail(2)) SWIG_fail;
21709 if (arg2 == NULL) {
21710 SWIG_null_ref("wxDateTime");
21711 }
21712 if (SWIG_arg_fail(2)) SWIG_fail;
21713 }
21714 {
21715 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21716 if (SWIG_arg_fail(3)) SWIG_fail;
21717 if (arg3 == NULL) {
21718 SWIG_null_ref("wxDateTime");
21719 }
21720 if (SWIG_arg_fail(3)) SWIG_fail;
21721 }
21722 {
21723 PyThreadState* __tstate = wxPyBeginAllowThreads();
21724 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21725
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 {
21730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21731 }
21732 return resultobj;
21733 fail:
21734 return NULL;
21735 }
21736
21737
21738 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21739 PyObject *resultobj;
21740 wxDateTime *arg1 = (wxDateTime *) 0 ;
21741 wxDateTime *arg2 = 0 ;
21742 wxDateTime *arg3 = 0 ;
21743 bool result;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 PyObject * obj2 = 0 ;
21747 char *kwnames[] = {
21748 (char *) "self",(char *) "t1",(char *) "t2", NULL
21749 };
21750
21751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21753 if (SWIG_arg_fail(1)) SWIG_fail;
21754 {
21755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21756 if (SWIG_arg_fail(2)) SWIG_fail;
21757 if (arg2 == NULL) {
21758 SWIG_null_ref("wxDateTime");
21759 }
21760 if (SWIG_arg_fail(2)) SWIG_fail;
21761 }
21762 {
21763 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21764 if (SWIG_arg_fail(3)) SWIG_fail;
21765 if (arg3 == NULL) {
21766 SWIG_null_ref("wxDateTime");
21767 }
21768 if (SWIG_arg_fail(3)) SWIG_fail;
21769 }
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21773
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 {
21778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21779 }
21780 return resultobj;
21781 fail:
21782 return NULL;
21783 }
21784
21785
21786 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj;
21788 wxDateTime *arg1 = (wxDateTime *) 0 ;
21789 wxDateTime *arg2 = 0 ;
21790 bool result;
21791 PyObject * obj0 = 0 ;
21792 PyObject * obj1 = 0 ;
21793 char *kwnames[] = {
21794 (char *) "self",(char *) "dt", NULL
21795 };
21796
21797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21799 if (SWIG_arg_fail(1)) SWIG_fail;
21800 {
21801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21802 if (SWIG_arg_fail(2)) SWIG_fail;
21803 if (arg2 == NULL) {
21804 SWIG_null_ref("wxDateTime");
21805 }
21806 if (SWIG_arg_fail(2)) SWIG_fail;
21807 }
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21811
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 {
21816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21817 }
21818 return resultobj;
21819 fail:
21820 return NULL;
21821 }
21822
21823
21824 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21825 PyObject *resultobj;
21826 wxDateTime *arg1 = (wxDateTime *) 0 ;
21827 wxDateTime *arg2 = 0 ;
21828 bool result;
21829 PyObject * obj0 = 0 ;
21830 PyObject * obj1 = 0 ;
21831 char *kwnames[] = {
21832 (char *) "self",(char *) "dt", NULL
21833 };
21834
21835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21837 if (SWIG_arg_fail(1)) SWIG_fail;
21838 {
21839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(2)) SWIG_fail;
21841 if (arg2 == NULL) {
21842 SWIG_null_ref("wxDateTime");
21843 }
21844 if (SWIG_arg_fail(2)) SWIG_fail;
21845 }
21846 {
21847 PyThreadState* __tstate = wxPyBeginAllowThreads();
21848 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21849
21850 wxPyEndAllowThreads(__tstate);
21851 if (PyErr_Occurred()) SWIG_fail;
21852 }
21853 {
21854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21855 }
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21863 PyObject *resultobj;
21864 wxDateTime *arg1 = (wxDateTime *) 0 ;
21865 wxDateTime *arg2 = 0 ;
21866 wxTimeSpan *arg3 = 0 ;
21867 bool result;
21868 PyObject * obj0 = 0 ;
21869 PyObject * obj1 = 0 ;
21870 PyObject * obj2 = 0 ;
21871 char *kwnames[] = {
21872 (char *) "self",(char *) "dt",(char *) "ts", NULL
21873 };
21874
21875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21877 if (SWIG_arg_fail(1)) SWIG_fail;
21878 {
21879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21880 if (SWIG_arg_fail(2)) SWIG_fail;
21881 if (arg2 == NULL) {
21882 SWIG_null_ref("wxDateTime");
21883 }
21884 if (SWIG_arg_fail(2)) SWIG_fail;
21885 }
21886 {
21887 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21888 if (SWIG_arg_fail(3)) SWIG_fail;
21889 if (arg3 == NULL) {
21890 SWIG_null_ref("wxTimeSpan");
21891 }
21892 if (SWIG_arg_fail(3)) SWIG_fail;
21893 }
21894 {
21895 PyThreadState* __tstate = wxPyBeginAllowThreads();
21896 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21897
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 {
21902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21903 }
21904 return resultobj;
21905 fail:
21906 return NULL;
21907 }
21908
21909
21910 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21911 PyObject *resultobj;
21912 wxDateTime *arg1 = (wxDateTime *) 0 ;
21913 wxTimeSpan *arg2 = 0 ;
21914 wxDateTime *result;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 char *kwnames[] = {
21918 (char *) "self",(char *) "diff", NULL
21919 };
21920
21921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21923 if (SWIG_arg_fail(1)) SWIG_fail;
21924 {
21925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21926 if (SWIG_arg_fail(2)) SWIG_fail;
21927 if (arg2 == NULL) {
21928 SWIG_null_ref("wxTimeSpan");
21929 }
21930 if (SWIG_arg_fail(2)) SWIG_fail;
21931 }
21932 {
21933 PyThreadState* __tstate = wxPyBeginAllowThreads();
21934 {
21935 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21936 result = (wxDateTime *) &_result_ref;
21937 }
21938
21939 wxPyEndAllowThreads(__tstate);
21940 if (PyErr_Occurred()) SWIG_fail;
21941 }
21942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21943 return resultobj;
21944 fail:
21945 return NULL;
21946 }
21947
21948
21949 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj;
21951 wxDateTime *arg1 = (wxDateTime *) 0 ;
21952 wxDateSpan *arg2 = 0 ;
21953 wxDateTime *result;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char *kwnames[] = {
21957 (char *) "self",(char *) "diff", NULL
21958 };
21959
21960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21962 if (SWIG_arg_fail(1)) SWIG_fail;
21963 {
21964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21965 if (SWIG_arg_fail(2)) SWIG_fail;
21966 if (arg2 == NULL) {
21967 SWIG_null_ref("wxDateSpan");
21968 }
21969 if (SWIG_arg_fail(2)) SWIG_fail;
21970 }
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 {
21974 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21975 result = (wxDateTime *) &_result_ref;
21976 }
21977
21978 wxPyEndAllowThreads(__tstate);
21979 if (PyErr_Occurred()) SWIG_fail;
21980 }
21981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21982 return resultobj;
21983 fail:
21984 return NULL;
21985 }
21986
21987
21988 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
21989 PyObject *resultobj;
21990 wxDateTime *arg1 = (wxDateTime *) 0 ;
21991 wxTimeSpan *arg2 = 0 ;
21992 wxDateTime *result;
21993 PyObject * obj0 = 0 ;
21994 PyObject * obj1 = 0 ;
21995 char *kwnames[] = {
21996 (char *) "self",(char *) "diff", NULL
21997 };
21998
21999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22001 if (SWIG_arg_fail(1)) SWIG_fail;
22002 {
22003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22004 if (SWIG_arg_fail(2)) SWIG_fail;
22005 if (arg2 == NULL) {
22006 SWIG_null_ref("wxTimeSpan");
22007 }
22008 if (SWIG_arg_fail(2)) SWIG_fail;
22009 }
22010 {
22011 PyThreadState* __tstate = wxPyBeginAllowThreads();
22012 {
22013 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22014 result = (wxDateTime *) &_result_ref;
22015 }
22016
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22028 PyObject *resultobj;
22029 wxDateTime *arg1 = (wxDateTime *) 0 ;
22030 wxDateSpan *arg2 = 0 ;
22031 wxDateTime *result;
22032 PyObject * obj0 = 0 ;
22033 PyObject * obj1 = 0 ;
22034 char *kwnames[] = {
22035 (char *) "self",(char *) "diff", NULL
22036 };
22037
22038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22040 if (SWIG_arg_fail(1)) SWIG_fail;
22041 {
22042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22043 if (SWIG_arg_fail(2)) SWIG_fail;
22044 if (arg2 == NULL) {
22045 SWIG_null_ref("wxDateSpan");
22046 }
22047 if (SWIG_arg_fail(2)) SWIG_fail;
22048 }
22049 {
22050 PyThreadState* __tstate = wxPyBeginAllowThreads();
22051 {
22052 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22053 result = (wxDateTime *) &_result_ref;
22054 }
22055
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22067 PyObject *resultobj;
22068 wxDateTime *arg1 = (wxDateTime *) 0 ;
22069 wxDateTime *arg2 = 0 ;
22070 wxTimeSpan result;
22071 PyObject * obj0 = 0 ;
22072 PyObject * obj1 = 0 ;
22073 char *kwnames[] = {
22074 (char *) "self",(char *) "dt", NULL
22075 };
22076
22077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22079 if (SWIG_arg_fail(1)) SWIG_fail;
22080 {
22081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22082 if (SWIG_arg_fail(2)) SWIG_fail;
22083 if (arg2 == NULL) {
22084 SWIG_null_ref("wxDateTime");
22085 }
22086 if (SWIG_arg_fail(2)) SWIG_fail;
22087 }
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22091
22092 wxPyEndAllowThreads(__tstate);
22093 if (PyErr_Occurred()) SWIG_fail;
22094 }
22095 {
22096 wxTimeSpan * resultptr;
22097 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22099 }
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22107 PyObject *resultobj;
22108 wxDateTime *arg1 = (wxDateTime *) 0 ;
22109 wxTimeSpan *arg2 = 0 ;
22110 wxDateTime *result;
22111 PyObject * obj0 = 0 ;
22112 PyObject * obj1 = 0 ;
22113
22114 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22116 if (SWIG_arg_fail(1)) SWIG_fail;
22117 {
22118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22119 if (SWIG_arg_fail(2)) SWIG_fail;
22120 if (arg2 == NULL) {
22121 SWIG_null_ref("wxTimeSpan");
22122 }
22123 if (SWIG_arg_fail(2)) SWIG_fail;
22124 }
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 {
22128 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22129 result = (wxDateTime *) &_result_ref;
22130 }
22131
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22143 PyObject *resultobj;
22144 wxDateTime *arg1 = (wxDateTime *) 0 ;
22145 wxDateSpan *arg2 = 0 ;
22146 wxDateTime *result;
22147 PyObject * obj0 = 0 ;
22148 PyObject * obj1 = 0 ;
22149
22150 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22152 if (SWIG_arg_fail(1)) SWIG_fail;
22153 {
22154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22155 if (SWIG_arg_fail(2)) SWIG_fail;
22156 if (arg2 == NULL) {
22157 SWIG_null_ref("wxDateSpan");
22158 }
22159 if (SWIG_arg_fail(2)) SWIG_fail;
22160 }
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 {
22164 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22165 result = (wxDateTime *) &_result_ref;
22166 }
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22179 int argc;
22180 PyObject *argv[3];
22181 int ii;
22182
22183 argc = PyObject_Length(args);
22184 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22185 argv[ii] = PyTuple_GetItem(args,ii);
22186 }
22187 if (argc == 2) {
22188 int _v;
22189 {
22190 void *ptr;
22191 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22192 _v = 0;
22193 PyErr_Clear();
22194 } else {
22195 _v = 1;
22196 }
22197 }
22198 if (_v) {
22199 {
22200 void *ptr = 0;
22201 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22202 _v = 0;
22203 PyErr_Clear();
22204 } else {
22205 _v = (ptr != 0);
22206 }
22207 }
22208 if (_v) {
22209 return _wrap_DateTime___iadd____SWIG_0(self,args);
22210 }
22211 }
22212 }
22213 if (argc == 2) {
22214 int _v;
22215 {
22216 void *ptr;
22217 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22218 _v = 0;
22219 PyErr_Clear();
22220 } else {
22221 _v = 1;
22222 }
22223 }
22224 if (_v) {
22225 {
22226 void *ptr = 0;
22227 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22228 _v = 0;
22229 PyErr_Clear();
22230 } else {
22231 _v = (ptr != 0);
22232 }
22233 }
22234 if (_v) {
22235 return _wrap_DateTime___iadd____SWIG_1(self,args);
22236 }
22237 }
22238 }
22239
22240 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22241 return NULL;
22242 }
22243
22244
22245 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22246 PyObject *resultobj;
22247 wxDateTime *arg1 = (wxDateTime *) 0 ;
22248 wxTimeSpan *arg2 = 0 ;
22249 wxDateTime *result;
22250 PyObject * obj0 = 0 ;
22251 PyObject * obj1 = 0 ;
22252
22253 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22255 if (SWIG_arg_fail(1)) SWIG_fail;
22256 {
22257 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22258 if (SWIG_arg_fail(2)) SWIG_fail;
22259 if (arg2 == NULL) {
22260 SWIG_null_ref("wxTimeSpan");
22261 }
22262 if (SWIG_arg_fail(2)) SWIG_fail;
22263 }
22264 {
22265 PyThreadState* __tstate = wxPyBeginAllowThreads();
22266 {
22267 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22268 result = (wxDateTime *) &_result_ref;
22269 }
22270
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22282 PyObject *resultobj;
22283 wxDateTime *arg1 = (wxDateTime *) 0 ;
22284 wxDateSpan *arg2 = 0 ;
22285 wxDateTime *result;
22286 PyObject * obj0 = 0 ;
22287 PyObject * obj1 = 0 ;
22288
22289 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22291 if (SWIG_arg_fail(1)) SWIG_fail;
22292 {
22293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22294 if (SWIG_arg_fail(2)) SWIG_fail;
22295 if (arg2 == NULL) {
22296 SWIG_null_ref("wxDateSpan");
22297 }
22298 if (SWIG_arg_fail(2)) SWIG_fail;
22299 }
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 {
22303 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22304 result = (wxDateTime *) &_result_ref;
22305 }
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22318 int argc;
22319 PyObject *argv[3];
22320 int ii;
22321
22322 argc = PyObject_Length(args);
22323 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22324 argv[ii] = PyTuple_GetItem(args,ii);
22325 }
22326 if (argc == 2) {
22327 int _v;
22328 {
22329 void *ptr;
22330 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22331 _v = 0;
22332 PyErr_Clear();
22333 } else {
22334 _v = 1;
22335 }
22336 }
22337 if (_v) {
22338 {
22339 void *ptr = 0;
22340 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22341 _v = 0;
22342 PyErr_Clear();
22343 } else {
22344 _v = (ptr != 0);
22345 }
22346 }
22347 if (_v) {
22348 return _wrap_DateTime___isub____SWIG_0(self,args);
22349 }
22350 }
22351 }
22352 if (argc == 2) {
22353 int _v;
22354 {
22355 void *ptr;
22356 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22357 _v = 0;
22358 PyErr_Clear();
22359 } else {
22360 _v = 1;
22361 }
22362 }
22363 if (_v) {
22364 {
22365 void *ptr = 0;
22366 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22367 _v = 0;
22368 PyErr_Clear();
22369 } else {
22370 _v = (ptr != 0);
22371 }
22372 }
22373 if (_v) {
22374 return _wrap_DateTime___isub____SWIG_1(self,args);
22375 }
22376 }
22377 }
22378
22379 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22380 return NULL;
22381 }
22382
22383
22384 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22385 PyObject *resultobj;
22386 wxDateTime *arg1 = (wxDateTime *) 0 ;
22387 wxTimeSpan *arg2 = 0 ;
22388 wxDateTime result;
22389 PyObject * obj0 = 0 ;
22390 PyObject * obj1 = 0 ;
22391
22392 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22394 if (SWIG_arg_fail(1)) SWIG_fail;
22395 {
22396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22397 if (SWIG_arg_fail(2)) SWIG_fail;
22398 if (arg2 == NULL) {
22399 SWIG_null_ref("wxTimeSpan");
22400 }
22401 if (SWIG_arg_fail(2)) SWIG_fail;
22402 }
22403 {
22404 PyThreadState* __tstate = wxPyBeginAllowThreads();
22405 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22406
22407 wxPyEndAllowThreads(__tstate);
22408 if (PyErr_Occurred()) SWIG_fail;
22409 }
22410 {
22411 wxDateTime * resultptr;
22412 resultptr = new wxDateTime((wxDateTime &)(result));
22413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22414 }
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22422 PyObject *resultobj;
22423 wxDateTime *arg1 = (wxDateTime *) 0 ;
22424 wxDateSpan *arg2 = 0 ;
22425 wxDateTime result;
22426 PyObject * obj0 = 0 ;
22427 PyObject * obj1 = 0 ;
22428
22429 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22431 if (SWIG_arg_fail(1)) SWIG_fail;
22432 {
22433 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(2)) SWIG_fail;
22435 if (arg2 == NULL) {
22436 SWIG_null_ref("wxDateSpan");
22437 }
22438 if (SWIG_arg_fail(2)) SWIG_fail;
22439 }
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22443
22444 wxPyEndAllowThreads(__tstate);
22445 if (PyErr_Occurred()) SWIG_fail;
22446 }
22447 {
22448 wxDateTime * resultptr;
22449 resultptr = new wxDateTime((wxDateTime &)(result));
22450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22451 }
22452 return resultobj;
22453 fail:
22454 return NULL;
22455 }
22456
22457
22458 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22459 int argc;
22460 PyObject *argv[3];
22461 int ii;
22462
22463 argc = PyObject_Length(args);
22464 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22465 argv[ii] = PyTuple_GetItem(args,ii);
22466 }
22467 if (argc == 2) {
22468 int _v;
22469 {
22470 void *ptr;
22471 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22472 _v = 0;
22473 PyErr_Clear();
22474 } else {
22475 _v = 1;
22476 }
22477 }
22478 if (_v) {
22479 {
22480 void *ptr = 0;
22481 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22482 _v = 0;
22483 PyErr_Clear();
22484 } else {
22485 _v = (ptr != 0);
22486 }
22487 }
22488 if (_v) {
22489 return _wrap_DateTime___add____SWIG_0(self,args);
22490 }
22491 }
22492 }
22493 if (argc == 2) {
22494 int _v;
22495 {
22496 void *ptr;
22497 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22498 _v = 0;
22499 PyErr_Clear();
22500 } else {
22501 _v = 1;
22502 }
22503 }
22504 if (_v) {
22505 {
22506 void *ptr = 0;
22507 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22508 _v = 0;
22509 PyErr_Clear();
22510 } else {
22511 _v = (ptr != 0);
22512 }
22513 }
22514 if (_v) {
22515 return _wrap_DateTime___add____SWIG_1(self,args);
22516 }
22517 }
22518 }
22519
22520 Py_INCREF(Py_NotImplemented);
22521 return Py_NotImplemented;
22522 }
22523
22524
22525 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22526 PyObject *resultobj;
22527 wxDateTime *arg1 = (wxDateTime *) 0 ;
22528 wxDateTime *arg2 = 0 ;
22529 wxTimeSpan result;
22530 PyObject * obj0 = 0 ;
22531 PyObject * obj1 = 0 ;
22532
22533 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22535 if (SWIG_arg_fail(1)) SWIG_fail;
22536 {
22537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22538 if (SWIG_arg_fail(2)) SWIG_fail;
22539 if (arg2 == NULL) {
22540 SWIG_null_ref("wxDateTime");
22541 }
22542 if (SWIG_arg_fail(2)) SWIG_fail;
22543 }
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22547
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 {
22552 wxTimeSpan * resultptr;
22553 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22555 }
22556 return resultobj;
22557 fail:
22558 return NULL;
22559 }
22560
22561
22562 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22563 PyObject *resultobj;
22564 wxDateTime *arg1 = (wxDateTime *) 0 ;
22565 wxTimeSpan *arg2 = 0 ;
22566 wxDateTime result;
22567 PyObject * obj0 = 0 ;
22568 PyObject * obj1 = 0 ;
22569
22570 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22572 if (SWIG_arg_fail(1)) SWIG_fail;
22573 {
22574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22575 if (SWIG_arg_fail(2)) SWIG_fail;
22576 if (arg2 == NULL) {
22577 SWIG_null_ref("wxTimeSpan");
22578 }
22579 if (SWIG_arg_fail(2)) SWIG_fail;
22580 }
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22584
22585 wxPyEndAllowThreads(__tstate);
22586 if (PyErr_Occurred()) SWIG_fail;
22587 }
22588 {
22589 wxDateTime * resultptr;
22590 resultptr = new wxDateTime((wxDateTime &)(result));
22591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22592 }
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22600 PyObject *resultobj;
22601 wxDateTime *arg1 = (wxDateTime *) 0 ;
22602 wxDateSpan *arg2 = 0 ;
22603 wxDateTime result;
22604 PyObject * obj0 = 0 ;
22605 PyObject * obj1 = 0 ;
22606
22607 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22609 if (SWIG_arg_fail(1)) SWIG_fail;
22610 {
22611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22612 if (SWIG_arg_fail(2)) SWIG_fail;
22613 if (arg2 == NULL) {
22614 SWIG_null_ref("wxDateSpan");
22615 }
22616 if (SWIG_arg_fail(2)) SWIG_fail;
22617 }
22618 {
22619 PyThreadState* __tstate = wxPyBeginAllowThreads();
22620 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22621
22622 wxPyEndAllowThreads(__tstate);
22623 if (PyErr_Occurred()) SWIG_fail;
22624 }
22625 {
22626 wxDateTime * resultptr;
22627 resultptr = new wxDateTime((wxDateTime &)(result));
22628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22629 }
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22637 int argc;
22638 PyObject *argv[3];
22639 int ii;
22640
22641 argc = PyObject_Length(args);
22642 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22643 argv[ii] = PyTuple_GetItem(args,ii);
22644 }
22645 if (argc == 2) {
22646 int _v;
22647 {
22648 void *ptr;
22649 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22650 _v = 0;
22651 PyErr_Clear();
22652 } else {
22653 _v = 1;
22654 }
22655 }
22656 if (_v) {
22657 {
22658 void *ptr = 0;
22659 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22660 _v = 0;
22661 PyErr_Clear();
22662 } else {
22663 _v = (ptr != 0);
22664 }
22665 }
22666 if (_v) {
22667 return _wrap_DateTime___sub____SWIG_0(self,args);
22668 }
22669 }
22670 }
22671 if (argc == 2) {
22672 int _v;
22673 {
22674 void *ptr;
22675 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22676 _v = 0;
22677 PyErr_Clear();
22678 } else {
22679 _v = 1;
22680 }
22681 }
22682 if (_v) {
22683 {
22684 void *ptr = 0;
22685 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22686 _v = 0;
22687 PyErr_Clear();
22688 } else {
22689 _v = (ptr != 0);
22690 }
22691 }
22692 if (_v) {
22693 return _wrap_DateTime___sub____SWIG_1(self,args);
22694 }
22695 }
22696 }
22697 if (argc == 2) {
22698 int _v;
22699 {
22700 void *ptr;
22701 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22702 _v = 0;
22703 PyErr_Clear();
22704 } else {
22705 _v = 1;
22706 }
22707 }
22708 if (_v) {
22709 {
22710 void *ptr = 0;
22711 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22712 _v = 0;
22713 PyErr_Clear();
22714 } else {
22715 _v = (ptr != 0);
22716 }
22717 }
22718 if (_v) {
22719 return _wrap_DateTime___sub____SWIG_2(self,args);
22720 }
22721 }
22722 }
22723
22724 Py_INCREF(Py_NotImplemented);
22725 return Py_NotImplemented;
22726 }
22727
22728
22729 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22730 PyObject *resultobj;
22731 wxDateTime *arg1 = (wxDateTime *) 0 ;
22732 wxDateTime *arg2 = (wxDateTime *) 0 ;
22733 bool result;
22734 PyObject * obj0 = 0 ;
22735 PyObject * obj1 = 0 ;
22736 char *kwnames[] = {
22737 (char *) "self",(char *) "other", NULL
22738 };
22739
22740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22742 if (SWIG_arg_fail(1)) SWIG_fail;
22743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22744 if (SWIG_arg_fail(2)) SWIG_fail;
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22748
22749 wxPyEndAllowThreads(__tstate);
22750 if (PyErr_Occurred()) SWIG_fail;
22751 }
22752 {
22753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22754 }
22755 return resultobj;
22756 fail:
22757 return NULL;
22758 }
22759
22760
22761 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
22762 PyObject *resultobj;
22763 wxDateTime *arg1 = (wxDateTime *) 0 ;
22764 wxDateTime *arg2 = (wxDateTime *) 0 ;
22765 bool result;
22766 PyObject * obj0 = 0 ;
22767 PyObject * obj1 = 0 ;
22768 char *kwnames[] = {
22769 (char *) "self",(char *) "other", NULL
22770 };
22771
22772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22776 if (SWIG_arg_fail(2)) SWIG_fail;
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22780
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 {
22785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22786 }
22787 return resultobj;
22788 fail:
22789 return NULL;
22790 }
22791
22792
22793 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
22794 PyObject *resultobj;
22795 wxDateTime *arg1 = (wxDateTime *) 0 ;
22796 wxDateTime *arg2 = (wxDateTime *) 0 ;
22797 bool result;
22798 PyObject * obj0 = 0 ;
22799 PyObject * obj1 = 0 ;
22800 char *kwnames[] = {
22801 (char *) "self",(char *) "other", NULL
22802 };
22803
22804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
22805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22806 if (SWIG_arg_fail(1)) SWIG_fail;
22807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(2)) SWIG_fail;
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22812
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
22826 PyObject *resultobj;
22827 wxDateTime *arg1 = (wxDateTime *) 0 ;
22828 wxDateTime *arg2 = (wxDateTime *) 0 ;
22829 bool result;
22830 PyObject * obj0 = 0 ;
22831 PyObject * obj1 = 0 ;
22832 char *kwnames[] = {
22833 (char *) "self",(char *) "other", NULL
22834 };
22835
22836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
22837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22838 if (SWIG_arg_fail(1)) SWIG_fail;
22839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22840 if (SWIG_arg_fail(2)) SWIG_fail;
22841 {
22842 PyThreadState* __tstate = wxPyBeginAllowThreads();
22843 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22844
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 {
22849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22850 }
22851 return resultobj;
22852 fail:
22853 return NULL;
22854 }
22855
22856
22857 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
22858 PyObject *resultobj;
22859 wxDateTime *arg1 = (wxDateTime *) 0 ;
22860 wxDateTime *arg2 = (wxDateTime *) 0 ;
22861 bool result;
22862 PyObject * obj0 = 0 ;
22863 PyObject * obj1 = 0 ;
22864 char *kwnames[] = {
22865 (char *) "self",(char *) "other", NULL
22866 };
22867
22868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
22869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22870 if (SWIG_arg_fail(1)) SWIG_fail;
22871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22872 if (SWIG_arg_fail(2)) SWIG_fail;
22873 {
22874 PyThreadState* __tstate = wxPyBeginAllowThreads();
22875 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22876
22877 wxPyEndAllowThreads(__tstate);
22878 if (PyErr_Occurred()) SWIG_fail;
22879 }
22880 {
22881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22882 }
22883 return resultobj;
22884 fail:
22885 return NULL;
22886 }
22887
22888
22889 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
22890 PyObject *resultobj;
22891 wxDateTime *arg1 = (wxDateTime *) 0 ;
22892 wxDateTime *arg2 = (wxDateTime *) 0 ;
22893 bool result;
22894 PyObject * obj0 = 0 ;
22895 PyObject * obj1 = 0 ;
22896 char *kwnames[] = {
22897 (char *) "self",(char *) "other", NULL
22898 };
22899
22900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
22901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22902 if (SWIG_arg_fail(1)) SWIG_fail;
22903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22904 if (SWIG_arg_fail(2)) SWIG_fail;
22905 {
22906 PyThreadState* __tstate = wxPyBeginAllowThreads();
22907 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22908
22909 wxPyEndAllowThreads(__tstate);
22910 if (PyErr_Occurred()) SWIG_fail;
22911 }
22912 {
22913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22914 }
22915 return resultobj;
22916 fail:
22917 return NULL;
22918 }
22919
22920
22921 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22922 PyObject *resultobj;
22923 wxDateTime *arg1 = (wxDateTime *) 0 ;
22924 wxString *arg2 = 0 ;
22925 int result;
22926 bool temp2 = false ;
22927 PyObject * obj0 = 0 ;
22928 PyObject * obj1 = 0 ;
22929 char *kwnames[] = {
22930 (char *) "self",(char *) "date", NULL
22931 };
22932
22933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22935 if (SWIG_arg_fail(1)) SWIG_fail;
22936 {
22937 arg2 = wxString_in_helper(obj1);
22938 if (arg2 == NULL) SWIG_fail;
22939 temp2 = true;
22940 }
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22944
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 {
22949 resultobj = SWIG_From_int((int)(result));
22950 }
22951 {
22952 if (temp2)
22953 delete arg2;
22954 }
22955 return resultobj;
22956 fail:
22957 {
22958 if (temp2)
22959 delete arg2;
22960 }
22961 return NULL;
22962 }
22963
22964
22965 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22966 PyObject *resultobj;
22967 wxDateTime *arg1 = (wxDateTime *) 0 ;
22968 wxString *arg2 = 0 ;
22969 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22970 wxString *arg3 = (wxString *) &arg3_defvalue ;
22971 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22972 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22973 int result;
22974 bool temp2 = false ;
22975 bool temp3 = false ;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978 PyObject * obj2 = 0 ;
22979 PyObject * obj3 = 0 ;
22980 char *kwnames[] = {
22981 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22982 };
22983
22984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22986 if (SWIG_arg_fail(1)) SWIG_fail;
22987 {
22988 arg2 = wxString_in_helper(obj1);
22989 if (arg2 == NULL) SWIG_fail;
22990 temp2 = true;
22991 }
22992 if (obj2) {
22993 {
22994 arg3 = wxString_in_helper(obj2);
22995 if (arg3 == NULL) SWIG_fail;
22996 temp3 = true;
22997 }
22998 }
22999 if (obj3) {
23000 {
23001 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23002 if (SWIG_arg_fail(4)) SWIG_fail;
23003 if (arg4 == NULL) {
23004 SWIG_null_ref("wxDateTime");
23005 }
23006 if (SWIG_arg_fail(4)) SWIG_fail;
23007 }
23008 }
23009 {
23010 PyThreadState* __tstate = wxPyBeginAllowThreads();
23011 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23012
23013 wxPyEndAllowThreads(__tstate);
23014 if (PyErr_Occurred()) SWIG_fail;
23015 }
23016 {
23017 resultobj = SWIG_From_int((int)(result));
23018 }
23019 {
23020 if (temp2)
23021 delete arg2;
23022 }
23023 {
23024 if (temp3)
23025 delete arg3;
23026 }
23027 return resultobj;
23028 fail:
23029 {
23030 if (temp2)
23031 delete arg2;
23032 }
23033 {
23034 if (temp3)
23035 delete arg3;
23036 }
23037 return NULL;
23038 }
23039
23040
23041 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23042 PyObject *resultobj;
23043 wxDateTime *arg1 = (wxDateTime *) 0 ;
23044 wxString *arg2 = 0 ;
23045 int result;
23046 bool temp2 = false ;
23047 PyObject * obj0 = 0 ;
23048 PyObject * obj1 = 0 ;
23049 char *kwnames[] = {
23050 (char *) "self",(char *) "datetime", NULL
23051 };
23052
23053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23055 if (SWIG_arg_fail(1)) SWIG_fail;
23056 {
23057 arg2 = wxString_in_helper(obj1);
23058 if (arg2 == NULL) SWIG_fail;
23059 temp2 = true;
23060 }
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23064
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 {
23069 resultobj = SWIG_From_int((int)(result));
23070 }
23071 {
23072 if (temp2)
23073 delete arg2;
23074 }
23075 return resultobj;
23076 fail:
23077 {
23078 if (temp2)
23079 delete arg2;
23080 }
23081 return NULL;
23082 }
23083
23084
23085 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23086 PyObject *resultobj;
23087 wxDateTime *arg1 = (wxDateTime *) 0 ;
23088 wxString *arg2 = 0 ;
23089 int result;
23090 bool temp2 = false ;
23091 PyObject * obj0 = 0 ;
23092 PyObject * obj1 = 0 ;
23093 char *kwnames[] = {
23094 (char *) "self",(char *) "date", NULL
23095 };
23096
23097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23099 if (SWIG_arg_fail(1)) SWIG_fail;
23100 {
23101 arg2 = wxString_in_helper(obj1);
23102 if (arg2 == NULL) SWIG_fail;
23103 temp2 = true;
23104 }
23105 {
23106 PyThreadState* __tstate = wxPyBeginAllowThreads();
23107 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23108
23109 wxPyEndAllowThreads(__tstate);
23110 if (PyErr_Occurred()) SWIG_fail;
23111 }
23112 {
23113 resultobj = SWIG_From_int((int)(result));
23114 }
23115 {
23116 if (temp2)
23117 delete arg2;
23118 }
23119 return resultobj;
23120 fail:
23121 {
23122 if (temp2)
23123 delete arg2;
23124 }
23125 return NULL;
23126 }
23127
23128
23129 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23130 PyObject *resultobj;
23131 wxDateTime *arg1 = (wxDateTime *) 0 ;
23132 wxString *arg2 = 0 ;
23133 int result;
23134 bool temp2 = false ;
23135 PyObject * obj0 = 0 ;
23136 PyObject * obj1 = 0 ;
23137 char *kwnames[] = {
23138 (char *) "self",(char *) "time", NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23143 if (SWIG_arg_fail(1)) SWIG_fail;
23144 {
23145 arg2 = wxString_in_helper(obj1);
23146 if (arg2 == NULL) SWIG_fail;
23147 temp2 = true;
23148 }
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23152
23153 wxPyEndAllowThreads(__tstate);
23154 if (PyErr_Occurred()) SWIG_fail;
23155 }
23156 {
23157 resultobj = SWIG_From_int((int)(result));
23158 }
23159 {
23160 if (temp2)
23161 delete arg2;
23162 }
23163 return resultobj;
23164 fail:
23165 {
23166 if (temp2)
23167 delete arg2;
23168 }
23169 return NULL;
23170 }
23171
23172
23173 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23174 PyObject *resultobj;
23175 wxDateTime *arg1 = (wxDateTime *) 0 ;
23176 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23177 wxString *arg2 = (wxString *) &arg2_defvalue ;
23178 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23179 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23180 wxString result;
23181 bool temp2 = false ;
23182 bool temp3 = false ;
23183 PyObject * obj0 = 0 ;
23184 PyObject * obj1 = 0 ;
23185 PyObject * obj2 = 0 ;
23186 char *kwnames[] = {
23187 (char *) "self",(char *) "format",(char *) "tz", NULL
23188 };
23189
23190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23192 if (SWIG_arg_fail(1)) SWIG_fail;
23193 if (obj1) {
23194 {
23195 arg2 = wxString_in_helper(obj1);
23196 if (arg2 == NULL) SWIG_fail;
23197 temp2 = true;
23198 }
23199 }
23200 if (obj2) {
23201 {
23202 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23203 temp3 = true;
23204 }
23205 }
23206 {
23207 PyThreadState* __tstate = wxPyBeginAllowThreads();
23208 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23209
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 {
23214 #if wxUSE_UNICODE
23215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23216 #else
23217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23218 #endif
23219 }
23220 {
23221 if (temp2)
23222 delete arg2;
23223 }
23224 {
23225 if (temp3) delete arg3;
23226 }
23227 return resultobj;
23228 fail:
23229 {
23230 if (temp2)
23231 delete arg2;
23232 }
23233 {
23234 if (temp3) delete arg3;
23235 }
23236 return NULL;
23237 }
23238
23239
23240 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23241 PyObject *resultobj;
23242 wxDateTime *arg1 = (wxDateTime *) 0 ;
23243 wxString result;
23244 PyObject * obj0 = 0 ;
23245 char *kwnames[] = {
23246 (char *) "self", NULL
23247 };
23248
23249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23251 if (SWIG_arg_fail(1)) SWIG_fail;
23252 {
23253 PyThreadState* __tstate = wxPyBeginAllowThreads();
23254 result = ((wxDateTime const *)arg1)->FormatDate();
23255
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 {
23260 #if wxUSE_UNICODE
23261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23262 #else
23263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23264 #endif
23265 }
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23273 PyObject *resultobj;
23274 wxDateTime *arg1 = (wxDateTime *) 0 ;
23275 wxString result;
23276 PyObject * obj0 = 0 ;
23277 char *kwnames[] = {
23278 (char *) "self", NULL
23279 };
23280
23281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23283 if (SWIG_arg_fail(1)) SWIG_fail;
23284 {
23285 PyThreadState* __tstate = wxPyBeginAllowThreads();
23286 result = ((wxDateTime const *)arg1)->FormatTime();
23287
23288 wxPyEndAllowThreads(__tstate);
23289 if (PyErr_Occurred()) SWIG_fail;
23290 }
23291 {
23292 #if wxUSE_UNICODE
23293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23294 #else
23295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23296 #endif
23297 }
23298 return resultobj;
23299 fail:
23300 return NULL;
23301 }
23302
23303
23304 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23305 PyObject *resultobj;
23306 wxDateTime *arg1 = (wxDateTime *) 0 ;
23307 wxString result;
23308 PyObject * obj0 = 0 ;
23309 char *kwnames[] = {
23310 (char *) "self", NULL
23311 };
23312
23313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23315 if (SWIG_arg_fail(1)) SWIG_fail;
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 result = ((wxDateTime const *)arg1)->FormatISODate();
23319
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 {
23324 #if wxUSE_UNICODE
23325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23326 #else
23327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23328 #endif
23329 }
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj;
23338 wxDateTime *arg1 = (wxDateTime *) 0 ;
23339 wxString result;
23340 PyObject * obj0 = 0 ;
23341 char *kwnames[] = {
23342 (char *) "self", NULL
23343 };
23344
23345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23347 if (SWIG_arg_fail(1)) SWIG_fail;
23348 {
23349 PyThreadState* __tstate = wxPyBeginAllowThreads();
23350 result = ((wxDateTime const *)arg1)->FormatISOTime();
23351
23352 wxPyEndAllowThreads(__tstate);
23353 if (PyErr_Occurred()) SWIG_fail;
23354 }
23355 {
23356 #if wxUSE_UNICODE
23357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23358 #else
23359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23360 #endif
23361 }
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23369 PyObject *obj;
23370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23371 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23372 Py_INCREF(obj);
23373 return Py_BuildValue((char *)"");
23374 }
23375 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23376 PyObject *resultobj;
23377 long arg1 ;
23378 wxTimeSpan result;
23379 PyObject * obj0 = 0 ;
23380 char *kwnames[] = {
23381 (char *) "sec", NULL
23382 };
23383
23384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23385 {
23386 arg1 = (long)(SWIG_As_long(obj0));
23387 if (SWIG_arg_fail(1)) SWIG_fail;
23388 }
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = wxTimeSpan::Seconds(arg1);
23392
23393 wxPyEndAllowThreads(__tstate);
23394 if (PyErr_Occurred()) SWIG_fail;
23395 }
23396 {
23397 wxTimeSpan * resultptr;
23398 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23399 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23400 }
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23408 PyObject *resultobj;
23409 wxTimeSpan result;
23410 char *kwnames[] = {
23411 NULL
23412 };
23413
23414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23415 {
23416 PyThreadState* __tstate = wxPyBeginAllowThreads();
23417 result = wxTimeSpan::Second();
23418
23419 wxPyEndAllowThreads(__tstate);
23420 if (PyErr_Occurred()) SWIG_fail;
23421 }
23422 {
23423 wxTimeSpan * resultptr;
23424 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23426 }
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj;
23435 long arg1 ;
23436 wxTimeSpan result;
23437 PyObject * obj0 = 0 ;
23438 char *kwnames[] = {
23439 (char *) "min", NULL
23440 };
23441
23442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23443 {
23444 arg1 = (long)(SWIG_As_long(obj0));
23445 if (SWIG_arg_fail(1)) SWIG_fail;
23446 }
23447 {
23448 PyThreadState* __tstate = wxPyBeginAllowThreads();
23449 result = wxTimeSpan::Minutes(arg1);
23450
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 {
23455 wxTimeSpan * resultptr;
23456 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23458 }
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj;
23467 wxTimeSpan result;
23468 char *kwnames[] = {
23469 NULL
23470 };
23471
23472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = wxTimeSpan::Minute();
23476
23477 wxPyEndAllowThreads(__tstate);
23478 if (PyErr_Occurred()) SWIG_fail;
23479 }
23480 {
23481 wxTimeSpan * resultptr;
23482 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23484 }
23485 return resultobj;
23486 fail:
23487 return NULL;
23488 }
23489
23490
23491 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23492 PyObject *resultobj;
23493 long arg1 ;
23494 wxTimeSpan result;
23495 PyObject * obj0 = 0 ;
23496 char *kwnames[] = {
23497 (char *) "hours", NULL
23498 };
23499
23500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23501 {
23502 arg1 = (long)(SWIG_As_long(obj0));
23503 if (SWIG_arg_fail(1)) SWIG_fail;
23504 }
23505 {
23506 PyThreadState* __tstate = wxPyBeginAllowThreads();
23507 result = wxTimeSpan::Hours(arg1);
23508
23509 wxPyEndAllowThreads(__tstate);
23510 if (PyErr_Occurred()) SWIG_fail;
23511 }
23512 {
23513 wxTimeSpan * resultptr;
23514 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23515 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23516 }
23517 return resultobj;
23518 fail:
23519 return NULL;
23520 }
23521
23522
23523 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj;
23525 wxTimeSpan result;
23526 char *kwnames[] = {
23527 NULL
23528 };
23529
23530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23531 {
23532 PyThreadState* __tstate = wxPyBeginAllowThreads();
23533 result = wxTimeSpan::Hour();
23534
23535 wxPyEndAllowThreads(__tstate);
23536 if (PyErr_Occurred()) SWIG_fail;
23537 }
23538 {
23539 wxTimeSpan * resultptr;
23540 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23542 }
23543 return resultobj;
23544 fail:
23545 return NULL;
23546 }
23547
23548
23549 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23550 PyObject *resultobj;
23551 long arg1 ;
23552 wxTimeSpan result;
23553 PyObject * obj0 = 0 ;
23554 char *kwnames[] = {
23555 (char *) "days", NULL
23556 };
23557
23558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23559 {
23560 arg1 = (long)(SWIG_As_long(obj0));
23561 if (SWIG_arg_fail(1)) SWIG_fail;
23562 }
23563 {
23564 PyThreadState* __tstate = wxPyBeginAllowThreads();
23565 result = wxTimeSpan::Days(arg1);
23566
23567 wxPyEndAllowThreads(__tstate);
23568 if (PyErr_Occurred()) SWIG_fail;
23569 }
23570 {
23571 wxTimeSpan * resultptr;
23572 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23574 }
23575 return resultobj;
23576 fail:
23577 return NULL;
23578 }
23579
23580
23581 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23582 PyObject *resultobj;
23583 wxTimeSpan result;
23584 char *kwnames[] = {
23585 NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = wxTimeSpan::Day();
23592
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 {
23597 wxTimeSpan * resultptr;
23598 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 long arg1 ;
23610 wxTimeSpan result;
23611 PyObject * obj0 = 0 ;
23612 char *kwnames[] = {
23613 (char *) "days", NULL
23614 };
23615
23616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23617 {
23618 arg1 = (long)(SWIG_As_long(obj0));
23619 if (SWIG_arg_fail(1)) SWIG_fail;
23620 }
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = wxTimeSpan::Weeks(arg1);
23624
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 wxTimeSpan * resultptr;
23630 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23632 }
23633 return resultobj;
23634 fail:
23635 return NULL;
23636 }
23637
23638
23639 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23640 PyObject *resultobj;
23641 wxTimeSpan result;
23642 char *kwnames[] = {
23643 NULL
23644 };
23645
23646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = wxTimeSpan::Week();
23650
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 wxTimeSpan * resultptr;
23656 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23657 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23658 }
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23666 PyObject *resultobj;
23667 long arg1 = (long) 0 ;
23668 long arg2 = (long) 0 ;
23669 long arg3 = (long) 0 ;
23670 long arg4 = (long) 0 ;
23671 wxTimeSpan *result;
23672 PyObject * obj0 = 0 ;
23673 PyObject * obj1 = 0 ;
23674 PyObject * obj2 = 0 ;
23675 PyObject * obj3 = 0 ;
23676 char *kwnames[] = {
23677 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23678 };
23679
23680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23681 if (obj0) {
23682 {
23683 arg1 = (long)(SWIG_As_long(obj0));
23684 if (SWIG_arg_fail(1)) SWIG_fail;
23685 }
23686 }
23687 if (obj1) {
23688 {
23689 arg2 = (long)(SWIG_As_long(obj1));
23690 if (SWIG_arg_fail(2)) SWIG_fail;
23691 }
23692 }
23693 if (obj2) {
23694 {
23695 arg3 = (long)(SWIG_As_long(obj2));
23696 if (SWIG_arg_fail(3)) SWIG_fail;
23697 }
23698 }
23699 if (obj3) {
23700 {
23701 arg4 = (long)(SWIG_As_long(obj3));
23702 if (SWIG_arg_fail(4)) SWIG_fail;
23703 }
23704 }
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23708
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj;
23721 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23722 PyObject * obj0 = 0 ;
23723 char *kwnames[] = {
23724 (char *) "self", NULL
23725 };
23726
23727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23729 if (SWIG_arg_fail(1)) SWIG_fail;
23730 {
23731 PyThreadState* __tstate = wxPyBeginAllowThreads();
23732 delete arg1;
23733
23734 wxPyEndAllowThreads(__tstate);
23735 if (PyErr_Occurred()) SWIG_fail;
23736 }
23737 Py_INCREF(Py_None); resultobj = Py_None;
23738 return resultobj;
23739 fail:
23740 return NULL;
23741 }
23742
23743
23744 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj;
23746 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23747 wxTimeSpan *arg2 = 0 ;
23748 wxTimeSpan *result;
23749 PyObject * obj0 = 0 ;
23750 PyObject * obj1 = 0 ;
23751 char *kwnames[] = {
23752 (char *) "self",(char *) "diff", NULL
23753 };
23754
23755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23757 if (SWIG_arg_fail(1)) SWIG_fail;
23758 {
23759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23760 if (SWIG_arg_fail(2)) SWIG_fail;
23761 if (arg2 == NULL) {
23762 SWIG_null_ref("wxTimeSpan");
23763 }
23764 if (SWIG_arg_fail(2)) SWIG_fail;
23765 }
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 {
23769 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23770 result = (wxTimeSpan *) &_result_ref;
23771 }
23772
23773 wxPyEndAllowThreads(__tstate);
23774 if (PyErr_Occurred()) SWIG_fail;
23775 }
23776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23777 return resultobj;
23778 fail:
23779 return NULL;
23780 }
23781
23782
23783 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23784 PyObject *resultobj;
23785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23786 wxTimeSpan *arg2 = 0 ;
23787 wxTimeSpan *result;
23788 PyObject * obj0 = 0 ;
23789 PyObject * obj1 = 0 ;
23790 char *kwnames[] = {
23791 (char *) "self",(char *) "diff", NULL
23792 };
23793
23794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 {
23798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23799 if (SWIG_arg_fail(2)) SWIG_fail;
23800 if (arg2 == NULL) {
23801 SWIG_null_ref("wxTimeSpan");
23802 }
23803 if (SWIG_arg_fail(2)) SWIG_fail;
23804 }
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 {
23808 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23809 result = (wxTimeSpan *) &_result_ref;
23810 }
23811
23812 wxPyEndAllowThreads(__tstate);
23813 if (PyErr_Occurred()) SWIG_fail;
23814 }
23815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj;
23824 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23825 int arg2 ;
23826 wxTimeSpan *result;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 char *kwnames[] = {
23830 (char *) "self",(char *) "n", NULL
23831 };
23832
23833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23835 if (SWIG_arg_fail(1)) SWIG_fail;
23836 {
23837 arg2 = (int)(SWIG_As_int(obj1));
23838 if (SWIG_arg_fail(2)) SWIG_fail;
23839 }
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 {
23843 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23844 result = (wxTimeSpan *) &_result_ref;
23845 }
23846
23847 wxPyEndAllowThreads(__tstate);
23848 if (PyErr_Occurred()) SWIG_fail;
23849 }
23850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj;
23859 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23860 wxTimeSpan *result;
23861 PyObject * obj0 = 0 ;
23862 char *kwnames[] = {
23863 (char *) "self", NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23868 if (SWIG_arg_fail(1)) SWIG_fail;
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 {
23872 wxTimeSpan &_result_ref = (arg1)->Neg();
23873 result = (wxTimeSpan *) &_result_ref;
23874 }
23875
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23880 return resultobj;
23881 fail:
23882 return NULL;
23883 }
23884
23885
23886 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23887 PyObject *resultobj;
23888 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23889 wxTimeSpan result;
23890 PyObject * obj0 = 0 ;
23891 char *kwnames[] = {
23892 (char *) "self", NULL
23893 };
23894
23895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23897 if (SWIG_arg_fail(1)) SWIG_fail;
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = ((wxTimeSpan const *)arg1)->Abs();
23901
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 {
23906 wxTimeSpan * resultptr;
23907 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23908 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23909 }
23910 return resultobj;
23911 fail:
23912 return NULL;
23913 }
23914
23915
23916 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23917 PyObject *resultobj;
23918 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23919 wxTimeSpan *arg2 = 0 ;
23920 wxTimeSpan *result;
23921 PyObject * obj0 = 0 ;
23922 PyObject * obj1 = 0 ;
23923 char *kwnames[] = {
23924 (char *) "self",(char *) "diff", NULL
23925 };
23926
23927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23929 if (SWIG_arg_fail(1)) SWIG_fail;
23930 {
23931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23932 if (SWIG_arg_fail(2)) SWIG_fail;
23933 if (arg2 == NULL) {
23934 SWIG_null_ref("wxTimeSpan");
23935 }
23936 if (SWIG_arg_fail(2)) SWIG_fail;
23937 }
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 {
23941 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23942 result = (wxTimeSpan *) &_result_ref;
23943 }
23944
23945 wxPyEndAllowThreads(__tstate);
23946 if (PyErr_Occurred()) SWIG_fail;
23947 }
23948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23949 return resultobj;
23950 fail:
23951 return NULL;
23952 }
23953
23954
23955 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23956 PyObject *resultobj;
23957 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23958 wxTimeSpan *arg2 = 0 ;
23959 wxTimeSpan *result;
23960 PyObject * obj0 = 0 ;
23961 PyObject * obj1 = 0 ;
23962 char *kwnames[] = {
23963 (char *) "self",(char *) "diff", NULL
23964 };
23965
23966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23968 if (SWIG_arg_fail(1)) SWIG_fail;
23969 {
23970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23971 if (SWIG_arg_fail(2)) SWIG_fail;
23972 if (arg2 == NULL) {
23973 SWIG_null_ref("wxTimeSpan");
23974 }
23975 if (SWIG_arg_fail(2)) SWIG_fail;
23976 }
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 {
23980 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23981 result = (wxTimeSpan *) &_result_ref;
23982 }
23983
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23988 return resultobj;
23989 fail:
23990 return NULL;
23991 }
23992
23993
23994 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
23995 PyObject *resultobj;
23996 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23997 int arg2 ;
23998 wxTimeSpan *result;
23999 PyObject * obj0 = 0 ;
24000 PyObject * obj1 = 0 ;
24001 char *kwnames[] = {
24002 (char *) "self",(char *) "n", NULL
24003 };
24004
24005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24007 if (SWIG_arg_fail(1)) SWIG_fail;
24008 {
24009 arg2 = (int)(SWIG_As_int(obj1));
24010 if (SWIG_arg_fail(2)) SWIG_fail;
24011 }
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 {
24015 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24016 result = (wxTimeSpan *) &_result_ref;
24017 }
24018
24019 wxPyEndAllowThreads(__tstate);
24020 if (PyErr_Occurred()) SWIG_fail;
24021 }
24022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24023 return resultobj;
24024 fail:
24025 return NULL;
24026 }
24027
24028
24029 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24030 PyObject *resultobj;
24031 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24032 wxTimeSpan *result;
24033 PyObject * obj0 = 0 ;
24034 char *kwnames[] = {
24035 (char *) "self", NULL
24036 };
24037
24038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24040 if (SWIG_arg_fail(1)) SWIG_fail;
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 {
24044 wxTimeSpan &_result_ref = (arg1)->operator -();
24045 result = (wxTimeSpan *) &_result_ref;
24046 }
24047
24048 wxPyEndAllowThreads(__tstate);
24049 if (PyErr_Occurred()) SWIG_fail;
24050 }
24051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24052 return resultobj;
24053 fail:
24054 return NULL;
24055 }
24056
24057
24058 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24059 PyObject *resultobj;
24060 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24061 wxTimeSpan *arg2 = 0 ;
24062 wxTimeSpan result;
24063 PyObject * obj0 = 0 ;
24064 PyObject * obj1 = 0 ;
24065 char *kwnames[] = {
24066 (char *) "self",(char *) "other", NULL
24067 };
24068
24069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24071 if (SWIG_arg_fail(1)) SWIG_fail;
24072 {
24073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24074 if (SWIG_arg_fail(2)) SWIG_fail;
24075 if (arg2 == NULL) {
24076 SWIG_null_ref("wxTimeSpan");
24077 }
24078 if (SWIG_arg_fail(2)) SWIG_fail;
24079 }
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24083
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 {
24088 wxTimeSpan * resultptr;
24089 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24091 }
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24099 PyObject *resultobj;
24100 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24101 wxTimeSpan *arg2 = 0 ;
24102 wxTimeSpan result;
24103 PyObject * obj0 = 0 ;
24104 PyObject * obj1 = 0 ;
24105 char *kwnames[] = {
24106 (char *) "self",(char *) "other", NULL
24107 };
24108
24109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24111 if (SWIG_arg_fail(1)) SWIG_fail;
24112 {
24113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24114 if (SWIG_arg_fail(2)) SWIG_fail;
24115 if (arg2 == NULL) {
24116 SWIG_null_ref("wxTimeSpan");
24117 }
24118 if (SWIG_arg_fail(2)) SWIG_fail;
24119 }
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24123
24124 wxPyEndAllowThreads(__tstate);
24125 if (PyErr_Occurred()) SWIG_fail;
24126 }
24127 {
24128 wxTimeSpan * resultptr;
24129 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24131 }
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj;
24140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24141 int arg2 ;
24142 wxTimeSpan result;
24143 PyObject * obj0 = 0 ;
24144 PyObject * obj1 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "self",(char *) "n", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 {
24153 arg2 = (int)(SWIG_As_int(obj1));
24154 if (SWIG_arg_fail(2)) SWIG_fail;
24155 }
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 result = wxTimeSpan___mul__(arg1,arg2);
24159
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 wxTimeSpan * resultptr;
24165 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24167 }
24168 return resultobj;
24169 fail:
24170 return NULL;
24171 }
24172
24173
24174 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24175 PyObject *resultobj;
24176 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24177 int arg2 ;
24178 wxTimeSpan result;
24179 PyObject * obj0 = 0 ;
24180 PyObject * obj1 = 0 ;
24181 char *kwnames[] = {
24182 (char *) "self",(char *) "n", NULL
24183 };
24184
24185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24187 if (SWIG_arg_fail(1)) SWIG_fail;
24188 {
24189 arg2 = (int)(SWIG_As_int(obj1));
24190 if (SWIG_arg_fail(2)) SWIG_fail;
24191 }
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 result = wxTimeSpan___rmul__(arg1,arg2);
24195
24196 wxPyEndAllowThreads(__tstate);
24197 if (PyErr_Occurred()) SWIG_fail;
24198 }
24199 {
24200 wxTimeSpan * resultptr;
24201 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24203 }
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24211 PyObject *resultobj;
24212 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24213 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24214 bool result;
24215 PyObject * obj0 = 0 ;
24216 PyObject * obj1 = 0 ;
24217 char *kwnames[] = {
24218 (char *) "self",(char *) "other", NULL
24219 };
24220
24221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24223 if (SWIG_arg_fail(1)) SWIG_fail;
24224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24225 if (SWIG_arg_fail(2)) SWIG_fail;
24226 {
24227 PyThreadState* __tstate = wxPyBeginAllowThreads();
24228 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24229
24230 wxPyEndAllowThreads(__tstate);
24231 if (PyErr_Occurred()) SWIG_fail;
24232 }
24233 {
24234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24235 }
24236 return resultobj;
24237 fail:
24238 return NULL;
24239 }
24240
24241
24242 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24243 PyObject *resultobj;
24244 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24245 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24246 bool result;
24247 PyObject * obj0 = 0 ;
24248 PyObject * obj1 = 0 ;
24249 char *kwnames[] = {
24250 (char *) "self",(char *) "other", NULL
24251 };
24252
24253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24255 if (SWIG_arg_fail(1)) SWIG_fail;
24256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24257 if (SWIG_arg_fail(2)) SWIG_fail;
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24261
24262 wxPyEndAllowThreads(__tstate);
24263 if (PyErr_Occurred()) SWIG_fail;
24264 }
24265 {
24266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24267 }
24268 return resultobj;
24269 fail:
24270 return NULL;
24271 }
24272
24273
24274 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24275 PyObject *resultobj;
24276 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24277 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24278 bool result;
24279 PyObject * obj0 = 0 ;
24280 PyObject * obj1 = 0 ;
24281 char *kwnames[] = {
24282 (char *) "self",(char *) "other", NULL
24283 };
24284
24285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24287 if (SWIG_arg_fail(1)) SWIG_fail;
24288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24289 if (SWIG_arg_fail(2)) SWIG_fail;
24290 {
24291 PyThreadState* __tstate = wxPyBeginAllowThreads();
24292 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24293
24294 wxPyEndAllowThreads(__tstate);
24295 if (PyErr_Occurred()) SWIG_fail;
24296 }
24297 {
24298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24299 }
24300 return resultobj;
24301 fail:
24302 return NULL;
24303 }
24304
24305
24306 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24307 PyObject *resultobj;
24308 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24309 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24310 bool result;
24311 PyObject * obj0 = 0 ;
24312 PyObject * obj1 = 0 ;
24313 char *kwnames[] = {
24314 (char *) "self",(char *) "other", NULL
24315 };
24316
24317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24319 if (SWIG_arg_fail(1)) SWIG_fail;
24320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24321 if (SWIG_arg_fail(2)) SWIG_fail;
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24325
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 {
24330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24331 }
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24339 PyObject *resultobj;
24340 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24341 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24342 bool result;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char *kwnames[] = {
24346 (char *) "self",(char *) "other", NULL
24347 };
24348
24349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24351 if (SWIG_arg_fail(1)) SWIG_fail;
24352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24353 if (SWIG_arg_fail(2)) SWIG_fail;
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24357
24358 wxPyEndAllowThreads(__tstate);
24359 if (PyErr_Occurred()) SWIG_fail;
24360 }
24361 {
24362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24363 }
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24371 PyObject *resultobj;
24372 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24373 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24374 bool result;
24375 PyObject * obj0 = 0 ;
24376 PyObject * obj1 = 0 ;
24377 char *kwnames[] = {
24378 (char *) "self",(char *) "other", NULL
24379 };
24380
24381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24383 if (SWIG_arg_fail(1)) SWIG_fail;
24384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24385 if (SWIG_arg_fail(2)) SWIG_fail;
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24389
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 {
24394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24395 }
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24405 bool result;
24406 PyObject * obj0 = 0 ;
24407 char *kwnames[] = {
24408 (char *) "self", NULL
24409 };
24410
24411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24413 if (SWIG_arg_fail(1)) SWIG_fail;
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24417
24418 wxPyEndAllowThreads(__tstate);
24419 if (PyErr_Occurred()) SWIG_fail;
24420 }
24421 {
24422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24423 }
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj;
24432 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24433 bool result;
24434 PyObject * obj0 = 0 ;
24435 char *kwnames[] = {
24436 (char *) "self", NULL
24437 };
24438
24439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24441 if (SWIG_arg_fail(1)) SWIG_fail;
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24445
24446 wxPyEndAllowThreads(__tstate);
24447 if (PyErr_Occurred()) SWIG_fail;
24448 }
24449 {
24450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24451 }
24452 return resultobj;
24453 fail:
24454 return NULL;
24455 }
24456
24457
24458 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24459 PyObject *resultobj;
24460 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24461 bool result;
24462 PyObject * obj0 = 0 ;
24463 char *kwnames[] = {
24464 (char *) "self", NULL
24465 };
24466
24467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24469 if (SWIG_arg_fail(1)) SWIG_fail;
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24473
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 {
24478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24479 }
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj;
24488 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24489 wxTimeSpan *arg2 = 0 ;
24490 bool result;
24491 PyObject * obj0 = 0 ;
24492 PyObject * obj1 = 0 ;
24493 char *kwnames[] = {
24494 (char *) "self",(char *) "ts", NULL
24495 };
24496
24497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24499 if (SWIG_arg_fail(1)) SWIG_fail;
24500 {
24501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24502 if (SWIG_arg_fail(2)) SWIG_fail;
24503 if (arg2 == NULL) {
24504 SWIG_null_ref("wxTimeSpan");
24505 }
24506 if (SWIG_arg_fail(2)) SWIG_fail;
24507 }
24508 {
24509 PyThreadState* __tstate = wxPyBeginAllowThreads();
24510 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24511
24512 wxPyEndAllowThreads(__tstate);
24513 if (PyErr_Occurred()) SWIG_fail;
24514 }
24515 {
24516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24517 }
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24525 PyObject *resultobj;
24526 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24527 wxTimeSpan *arg2 = 0 ;
24528 bool result;
24529 PyObject * obj0 = 0 ;
24530 PyObject * obj1 = 0 ;
24531 char *kwnames[] = {
24532 (char *) "self",(char *) "ts", NULL
24533 };
24534
24535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24537 if (SWIG_arg_fail(1)) SWIG_fail;
24538 {
24539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24540 if (SWIG_arg_fail(2)) SWIG_fail;
24541 if (arg2 == NULL) {
24542 SWIG_null_ref("wxTimeSpan");
24543 }
24544 if (SWIG_arg_fail(2)) SWIG_fail;
24545 }
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24549
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 {
24554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24555 }
24556 return resultobj;
24557 fail:
24558 return NULL;
24559 }
24560
24561
24562 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24563 PyObject *resultobj;
24564 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24565 wxTimeSpan *arg2 = 0 ;
24566 bool result;
24567 PyObject * obj0 = 0 ;
24568 PyObject * obj1 = 0 ;
24569 char *kwnames[] = {
24570 (char *) "self",(char *) "t", NULL
24571 };
24572
24573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24575 if (SWIG_arg_fail(1)) SWIG_fail;
24576 {
24577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24578 if (SWIG_arg_fail(2)) SWIG_fail;
24579 if (arg2 == NULL) {
24580 SWIG_null_ref("wxTimeSpan");
24581 }
24582 if (SWIG_arg_fail(2)) SWIG_fail;
24583 }
24584 {
24585 PyThreadState* __tstate = wxPyBeginAllowThreads();
24586 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24587
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 {
24592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24593 }
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24601 PyObject *resultobj;
24602 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24603 int result;
24604 PyObject * obj0 = 0 ;
24605 char *kwnames[] = {
24606 (char *) "self", NULL
24607 };
24608
24609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24611 if (SWIG_arg_fail(1)) SWIG_fail;
24612 {
24613 PyThreadState* __tstate = wxPyBeginAllowThreads();
24614 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24615
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 {
24620 resultobj = SWIG_From_int((int)(result));
24621 }
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24629 PyObject *resultobj;
24630 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24631 int result;
24632 PyObject * obj0 = 0 ;
24633 char *kwnames[] = {
24634 (char *) "self", NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24639 if (SWIG_arg_fail(1)) SWIG_fail;
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24643
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 {
24648 resultobj = SWIG_From_int((int)(result));
24649 }
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24657 PyObject *resultobj;
24658 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24659 int result;
24660 PyObject * obj0 = 0 ;
24661 char *kwnames[] = {
24662 (char *) "self", NULL
24663 };
24664
24665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24667 if (SWIG_arg_fail(1)) SWIG_fail;
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24671
24672 wxPyEndAllowThreads(__tstate);
24673 if (PyErr_Occurred()) SWIG_fail;
24674 }
24675 {
24676 resultobj = SWIG_From_int((int)(result));
24677 }
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj;
24686 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24687 int result;
24688 PyObject * obj0 = 0 ;
24689 char *kwnames[] = {
24690 (char *) "self", NULL
24691 };
24692
24693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24695 if (SWIG_arg_fail(1)) SWIG_fail;
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24699
24700 wxPyEndAllowThreads(__tstate);
24701 if (PyErr_Occurred()) SWIG_fail;
24702 }
24703 {
24704 resultobj = SWIG_From_int((int)(result));
24705 }
24706 return resultobj;
24707 fail:
24708 return NULL;
24709 }
24710
24711
24712 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24713 PyObject *resultobj;
24714 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24715 wxLongLong result;
24716 PyObject * obj0 = 0 ;
24717 char *kwnames[] = {
24718 (char *) "self", NULL
24719 };
24720
24721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24723 if (SWIG_arg_fail(1)) SWIG_fail;
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24727
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 PyObject *hi, *lo, *shifter, *shifted;
24733 hi = PyLong_FromLong( (&result)->GetHi() );
24734 lo = PyLong_FromLong( (&result)->GetLo() );
24735 shifter = PyLong_FromLong(32);
24736 shifted = PyNumber_Lshift(hi, shifter);
24737 resultobj = PyNumber_Or(shifted, lo);
24738 Py_DECREF(hi);
24739 Py_DECREF(lo);
24740 Py_DECREF(shifter);
24741 Py_DECREF(shifted);
24742 }
24743 return resultobj;
24744 fail:
24745 return NULL;
24746 }
24747
24748
24749 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24750 PyObject *resultobj;
24751 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24752 wxLongLong result;
24753 PyObject * obj0 = 0 ;
24754 char *kwnames[] = {
24755 (char *) "self", NULL
24756 };
24757
24758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24760 if (SWIG_arg_fail(1)) SWIG_fail;
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24764
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 {
24769 PyObject *hi, *lo, *shifter, *shifted;
24770 hi = PyLong_FromLong( (&result)->GetHi() );
24771 lo = PyLong_FromLong( (&result)->GetLo() );
24772 shifter = PyLong_FromLong(32);
24773 shifted = PyNumber_Lshift(hi, shifter);
24774 resultobj = PyNumber_Or(shifted, lo);
24775 Py_DECREF(hi);
24776 Py_DECREF(lo);
24777 Py_DECREF(shifter);
24778 Py_DECREF(shifted);
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24787 PyObject *resultobj;
24788 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24789 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24790 wxString *arg2 = (wxString *) &arg2_defvalue ;
24791 wxString result;
24792 bool temp2 = false ;
24793 PyObject * obj0 = 0 ;
24794 PyObject * obj1 = 0 ;
24795 char *kwnames[] = {
24796 (char *) "self",(char *) "format", NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(1)) SWIG_fail;
24802 if (obj1) {
24803 {
24804 arg2 = wxString_in_helper(obj1);
24805 if (arg2 == NULL) SWIG_fail;
24806 temp2 = true;
24807 }
24808 }
24809 {
24810 PyThreadState* __tstate = wxPyBeginAllowThreads();
24811 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24812
24813 wxPyEndAllowThreads(__tstate);
24814 if (PyErr_Occurred()) SWIG_fail;
24815 }
24816 {
24817 #if wxUSE_UNICODE
24818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24819 #else
24820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24821 #endif
24822 }
24823 {
24824 if (temp2)
24825 delete arg2;
24826 }
24827 return resultobj;
24828 fail:
24829 {
24830 if (temp2)
24831 delete arg2;
24832 }
24833 return NULL;
24834 }
24835
24836
24837 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24838 PyObject *obj;
24839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24840 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24841 Py_INCREF(obj);
24842 return Py_BuildValue((char *)"");
24843 }
24844 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24845 PyObject *resultobj;
24846 int arg1 = (int) 0 ;
24847 int arg2 = (int) 0 ;
24848 int arg3 = (int) 0 ;
24849 int arg4 = (int) 0 ;
24850 wxDateSpan *result;
24851 PyObject * obj0 = 0 ;
24852 PyObject * obj1 = 0 ;
24853 PyObject * obj2 = 0 ;
24854 PyObject * obj3 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24860 if (obj0) {
24861 {
24862 arg1 = (int)(SWIG_As_int(obj0));
24863 if (SWIG_arg_fail(1)) SWIG_fail;
24864 }
24865 }
24866 if (obj1) {
24867 {
24868 arg2 = (int)(SWIG_As_int(obj1));
24869 if (SWIG_arg_fail(2)) SWIG_fail;
24870 }
24871 }
24872 if (obj2) {
24873 {
24874 arg3 = (int)(SWIG_As_int(obj2));
24875 if (SWIG_arg_fail(3)) SWIG_fail;
24876 }
24877 }
24878 if (obj3) {
24879 {
24880 arg4 = (int)(SWIG_As_int(obj3));
24881 if (SWIG_arg_fail(4)) SWIG_fail;
24882 }
24883 }
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24887
24888 wxPyEndAllowThreads(__tstate);
24889 if (PyErr_Occurred()) SWIG_fail;
24890 }
24891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24892 return resultobj;
24893 fail:
24894 return NULL;
24895 }
24896
24897
24898 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24899 PyObject *resultobj;
24900 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24901 PyObject * obj0 = 0 ;
24902 char *kwnames[] = {
24903 (char *) "self", NULL
24904 };
24905
24906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24908 if (SWIG_arg_fail(1)) SWIG_fail;
24909 {
24910 PyThreadState* __tstate = wxPyBeginAllowThreads();
24911 delete arg1;
24912
24913 wxPyEndAllowThreads(__tstate);
24914 if (PyErr_Occurred()) SWIG_fail;
24915 }
24916 Py_INCREF(Py_None); resultobj = Py_None;
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj;
24925 int arg1 ;
24926 wxDateSpan result;
24927 PyObject * obj0 = 0 ;
24928 char *kwnames[] = {
24929 (char *) "days", NULL
24930 };
24931
24932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24933 {
24934 arg1 = (int)(SWIG_As_int(obj0));
24935 if (SWIG_arg_fail(1)) SWIG_fail;
24936 }
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = wxDateSpan::Days(arg1);
24940
24941 wxPyEndAllowThreads(__tstate);
24942 if (PyErr_Occurred()) SWIG_fail;
24943 }
24944 {
24945 wxDateSpan * resultptr;
24946 resultptr = new wxDateSpan((wxDateSpan &)(result));
24947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24948 }
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24956 PyObject *resultobj;
24957 wxDateSpan result;
24958 char *kwnames[] = {
24959 NULL
24960 };
24961
24962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 result = wxDateSpan::Day();
24966
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 {
24971 wxDateSpan * resultptr;
24972 resultptr = new wxDateSpan((wxDateSpan &)(result));
24973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj;
24983 int arg1 ;
24984 wxDateSpan result;
24985 PyObject * obj0 = 0 ;
24986 char *kwnames[] = {
24987 (char *) "weeks", NULL
24988 };
24989
24990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
24991 {
24992 arg1 = (int)(SWIG_As_int(obj0));
24993 if (SWIG_arg_fail(1)) SWIG_fail;
24994 }
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = wxDateSpan::Weeks(arg1);
24998
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 {
25003 wxDateSpan * resultptr;
25004 resultptr = new wxDateSpan((wxDateSpan &)(result));
25005 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25006 }
25007 return resultobj;
25008 fail:
25009 return NULL;
25010 }
25011
25012
25013 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25014 PyObject *resultobj;
25015 wxDateSpan result;
25016 char *kwnames[] = {
25017 NULL
25018 };
25019
25020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 result = wxDateSpan::Week();
25024
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 wxDateSpan * resultptr;
25030 resultptr = new wxDateSpan((wxDateSpan &)(result));
25031 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25032 }
25033 return resultobj;
25034 fail:
25035 return NULL;
25036 }
25037
25038
25039 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25040 PyObject *resultobj;
25041 int arg1 ;
25042 wxDateSpan result;
25043 PyObject * obj0 = 0 ;
25044 char *kwnames[] = {
25045 (char *) "mon", NULL
25046 };
25047
25048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25049 {
25050 arg1 = (int)(SWIG_As_int(obj0));
25051 if (SWIG_arg_fail(1)) SWIG_fail;
25052 }
25053 {
25054 PyThreadState* __tstate = wxPyBeginAllowThreads();
25055 result = wxDateSpan::Months(arg1);
25056
25057 wxPyEndAllowThreads(__tstate);
25058 if (PyErr_Occurred()) SWIG_fail;
25059 }
25060 {
25061 wxDateSpan * resultptr;
25062 resultptr = new wxDateSpan((wxDateSpan &)(result));
25063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj;
25073 wxDateSpan result;
25074 char *kwnames[] = {
25075 NULL
25076 };
25077
25078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25079 {
25080 PyThreadState* __tstate = wxPyBeginAllowThreads();
25081 result = wxDateSpan::Month();
25082
25083 wxPyEndAllowThreads(__tstate);
25084 if (PyErr_Occurred()) SWIG_fail;
25085 }
25086 {
25087 wxDateSpan * resultptr;
25088 resultptr = new wxDateSpan((wxDateSpan &)(result));
25089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25090 }
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj;
25099 int arg1 ;
25100 wxDateSpan result;
25101 PyObject * obj0 = 0 ;
25102 char *kwnames[] = {
25103 (char *) "years", NULL
25104 };
25105
25106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25107 {
25108 arg1 = (int)(SWIG_As_int(obj0));
25109 if (SWIG_arg_fail(1)) SWIG_fail;
25110 }
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = wxDateSpan::Years(arg1);
25114
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 {
25119 wxDateSpan * resultptr;
25120 resultptr = new wxDateSpan((wxDateSpan &)(result));
25121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25122 }
25123 return resultobj;
25124 fail:
25125 return NULL;
25126 }
25127
25128
25129 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25130 PyObject *resultobj;
25131 wxDateSpan result;
25132 char *kwnames[] = {
25133 NULL
25134 };
25135
25136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25137 {
25138 PyThreadState* __tstate = wxPyBeginAllowThreads();
25139 result = wxDateSpan::Year();
25140
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 {
25145 wxDateSpan * resultptr;
25146 resultptr = new wxDateSpan((wxDateSpan &)(result));
25147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25148 }
25149 return resultobj;
25150 fail:
25151 return NULL;
25152 }
25153
25154
25155 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25156 PyObject *resultobj;
25157 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25158 int arg2 ;
25159 wxDateSpan *result;
25160 PyObject * obj0 = 0 ;
25161 PyObject * obj1 = 0 ;
25162 char *kwnames[] = {
25163 (char *) "self",(char *) "n", NULL
25164 };
25165
25166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25168 if (SWIG_arg_fail(1)) SWIG_fail;
25169 {
25170 arg2 = (int)(SWIG_As_int(obj1));
25171 if (SWIG_arg_fail(2)) SWIG_fail;
25172 }
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 {
25176 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25177 result = (wxDateSpan *) &_result_ref;
25178 }
25179
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25191 PyObject *resultobj;
25192 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25193 int arg2 ;
25194 wxDateSpan *result;
25195 PyObject * obj0 = 0 ;
25196 PyObject * obj1 = 0 ;
25197 char *kwnames[] = {
25198 (char *) "self",(char *) "n", NULL
25199 };
25200
25201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25203 if (SWIG_arg_fail(1)) SWIG_fail;
25204 {
25205 arg2 = (int)(SWIG_As_int(obj1));
25206 if (SWIG_arg_fail(2)) SWIG_fail;
25207 }
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 {
25211 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25212 result = (wxDateSpan *) &_result_ref;
25213 }
25214
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj;
25227 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25228 int arg2 ;
25229 wxDateSpan *result;
25230 PyObject * obj0 = 0 ;
25231 PyObject * obj1 = 0 ;
25232 char *kwnames[] = {
25233 (char *) "self",(char *) "n", NULL
25234 };
25235
25236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25238 if (SWIG_arg_fail(1)) SWIG_fail;
25239 {
25240 arg2 = (int)(SWIG_As_int(obj1));
25241 if (SWIG_arg_fail(2)) SWIG_fail;
25242 }
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 {
25246 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25247 result = (wxDateSpan *) &_result_ref;
25248 }
25249
25250 wxPyEndAllowThreads(__tstate);
25251 if (PyErr_Occurred()) SWIG_fail;
25252 }
25253 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25254 return resultobj;
25255 fail:
25256 return NULL;
25257 }
25258
25259
25260 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25261 PyObject *resultobj;
25262 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25263 int arg2 ;
25264 wxDateSpan *result;
25265 PyObject * obj0 = 0 ;
25266 PyObject * obj1 = 0 ;
25267 char *kwnames[] = {
25268 (char *) "self",(char *) "n", NULL
25269 };
25270
25271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25273 if (SWIG_arg_fail(1)) SWIG_fail;
25274 {
25275 arg2 = (int)(SWIG_As_int(obj1));
25276 if (SWIG_arg_fail(2)) SWIG_fail;
25277 }
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 {
25281 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25282 result = (wxDateSpan *) &_result_ref;
25283 }
25284
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25296 PyObject *resultobj;
25297 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25298 int result;
25299 PyObject * obj0 = 0 ;
25300 char *kwnames[] = {
25301 (char *) "self", NULL
25302 };
25303
25304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25306 if (SWIG_arg_fail(1)) SWIG_fail;
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 result = (int)((wxDateSpan const *)arg1)->GetYears();
25310
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 {
25315 resultobj = SWIG_From_int((int)(result));
25316 }
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25324 PyObject *resultobj;
25325 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25326 int result;
25327 PyObject * obj0 = 0 ;
25328 char *kwnames[] = {
25329 (char *) "self", NULL
25330 };
25331
25332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25334 if (SWIG_arg_fail(1)) SWIG_fail;
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25338
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 {
25343 resultobj = SWIG_From_int((int)(result));
25344 }
25345 return resultobj;
25346 fail:
25347 return NULL;
25348 }
25349
25350
25351 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25352 PyObject *resultobj;
25353 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25354 int result;
25355 PyObject * obj0 = 0 ;
25356 char *kwnames[] = {
25357 (char *) "self", NULL
25358 };
25359
25360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25362 if (SWIG_arg_fail(1)) SWIG_fail;
25363 {
25364 PyThreadState* __tstate = wxPyBeginAllowThreads();
25365 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25366
25367 wxPyEndAllowThreads(__tstate);
25368 if (PyErr_Occurred()) SWIG_fail;
25369 }
25370 {
25371 resultobj = SWIG_From_int((int)(result));
25372 }
25373 return resultobj;
25374 fail:
25375 return NULL;
25376 }
25377
25378
25379 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25380 PyObject *resultobj;
25381 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25382 int result;
25383 PyObject * obj0 = 0 ;
25384 char *kwnames[] = {
25385 (char *) "self", NULL
25386 };
25387
25388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25390 if (SWIG_arg_fail(1)) SWIG_fail;
25391 {
25392 PyThreadState* __tstate = wxPyBeginAllowThreads();
25393 result = (int)((wxDateSpan const *)arg1)->GetDays();
25394
25395 wxPyEndAllowThreads(__tstate);
25396 if (PyErr_Occurred()) SWIG_fail;
25397 }
25398 {
25399 resultobj = SWIG_From_int((int)(result));
25400 }
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25408 PyObject *resultobj;
25409 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25410 int result;
25411 PyObject * obj0 = 0 ;
25412 char *kwnames[] = {
25413 (char *) "self", NULL
25414 };
25415
25416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25418 if (SWIG_arg_fail(1)) SWIG_fail;
25419 {
25420 PyThreadState* __tstate = wxPyBeginAllowThreads();
25421 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25422
25423 wxPyEndAllowThreads(__tstate);
25424 if (PyErr_Occurred()) SWIG_fail;
25425 }
25426 {
25427 resultobj = SWIG_From_int((int)(result));
25428 }
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj;
25437 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25438 wxDateSpan *arg2 = 0 ;
25439 wxDateSpan *result;
25440 PyObject * obj0 = 0 ;
25441 PyObject * obj1 = 0 ;
25442 char *kwnames[] = {
25443 (char *) "self",(char *) "other", NULL
25444 };
25445
25446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25448 if (SWIG_arg_fail(1)) SWIG_fail;
25449 {
25450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25451 if (SWIG_arg_fail(2)) SWIG_fail;
25452 if (arg2 == NULL) {
25453 SWIG_null_ref("wxDateSpan");
25454 }
25455 if (SWIG_arg_fail(2)) SWIG_fail;
25456 }
25457 {
25458 PyThreadState* __tstate = wxPyBeginAllowThreads();
25459 {
25460 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25461 result = (wxDateSpan *) &_result_ref;
25462 }
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj;
25476 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25477 wxDateSpan *arg2 = 0 ;
25478 wxDateSpan *result;
25479 PyObject * obj0 = 0 ;
25480 PyObject * obj1 = 0 ;
25481 char *kwnames[] = {
25482 (char *) "self",(char *) "other", NULL
25483 };
25484
25485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25487 if (SWIG_arg_fail(1)) SWIG_fail;
25488 {
25489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25490 if (SWIG_arg_fail(2)) SWIG_fail;
25491 if (arg2 == NULL) {
25492 SWIG_null_ref("wxDateSpan");
25493 }
25494 if (SWIG_arg_fail(2)) SWIG_fail;
25495 }
25496 {
25497 PyThreadState* __tstate = wxPyBeginAllowThreads();
25498 {
25499 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25500 result = (wxDateSpan *) &_result_ref;
25501 }
25502
25503 wxPyEndAllowThreads(__tstate);
25504 if (PyErr_Occurred()) SWIG_fail;
25505 }
25506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj;
25515 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25516 wxDateSpan *result;
25517 PyObject * obj0 = 0 ;
25518 char *kwnames[] = {
25519 (char *) "self", NULL
25520 };
25521
25522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25524 if (SWIG_arg_fail(1)) SWIG_fail;
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 {
25528 wxDateSpan &_result_ref = (arg1)->Neg();
25529 result = (wxDateSpan *) &_result_ref;
25530 }
25531
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25536 return resultobj;
25537 fail:
25538 return NULL;
25539 }
25540
25541
25542 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25543 PyObject *resultobj;
25544 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25545 int arg2 ;
25546 wxDateSpan *result;
25547 PyObject * obj0 = 0 ;
25548 PyObject * obj1 = 0 ;
25549 char *kwnames[] = {
25550 (char *) "self",(char *) "factor", NULL
25551 };
25552
25553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25555 if (SWIG_arg_fail(1)) SWIG_fail;
25556 {
25557 arg2 = (int)(SWIG_As_int(obj1));
25558 if (SWIG_arg_fail(2)) SWIG_fail;
25559 }
25560 {
25561 PyThreadState* __tstate = wxPyBeginAllowThreads();
25562 {
25563 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25564 result = (wxDateSpan *) &_result_ref;
25565 }
25566
25567 wxPyEndAllowThreads(__tstate);
25568 if (PyErr_Occurred()) SWIG_fail;
25569 }
25570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25571 return resultobj;
25572 fail:
25573 return NULL;
25574 }
25575
25576
25577 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj;
25579 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25580 wxDateSpan *arg2 = 0 ;
25581 wxDateSpan *result;
25582 PyObject * obj0 = 0 ;
25583 PyObject * obj1 = 0 ;
25584 char *kwnames[] = {
25585 (char *) "self",(char *) "other", NULL
25586 };
25587
25588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25590 if (SWIG_arg_fail(1)) SWIG_fail;
25591 {
25592 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25593 if (SWIG_arg_fail(2)) SWIG_fail;
25594 if (arg2 == NULL) {
25595 SWIG_null_ref("wxDateSpan");
25596 }
25597 if (SWIG_arg_fail(2)) SWIG_fail;
25598 }
25599 {
25600 PyThreadState* __tstate = wxPyBeginAllowThreads();
25601 {
25602 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25603 result = (wxDateSpan *) &_result_ref;
25604 }
25605
25606 wxPyEndAllowThreads(__tstate);
25607 if (PyErr_Occurred()) SWIG_fail;
25608 }
25609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25610 return resultobj;
25611 fail:
25612 return NULL;
25613 }
25614
25615
25616 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25617 PyObject *resultobj;
25618 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25619 wxDateSpan *arg2 = 0 ;
25620 wxDateSpan *result;
25621 PyObject * obj0 = 0 ;
25622 PyObject * obj1 = 0 ;
25623 char *kwnames[] = {
25624 (char *) "self",(char *) "other", NULL
25625 };
25626
25627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25629 if (SWIG_arg_fail(1)) SWIG_fail;
25630 {
25631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25632 if (SWIG_arg_fail(2)) SWIG_fail;
25633 if (arg2 == NULL) {
25634 SWIG_null_ref("wxDateSpan");
25635 }
25636 if (SWIG_arg_fail(2)) SWIG_fail;
25637 }
25638 {
25639 PyThreadState* __tstate = wxPyBeginAllowThreads();
25640 {
25641 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25642 result = (wxDateSpan *) &_result_ref;
25643 }
25644
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25658 wxDateSpan *result;
25659 PyObject * obj0 = 0 ;
25660 char *kwnames[] = {
25661 (char *) "self", NULL
25662 };
25663
25664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25666 if (SWIG_arg_fail(1)) SWIG_fail;
25667 {
25668 PyThreadState* __tstate = wxPyBeginAllowThreads();
25669 {
25670 wxDateSpan &_result_ref = (arg1)->operator -();
25671 result = (wxDateSpan *) &_result_ref;
25672 }
25673
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25685 PyObject *resultobj;
25686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25687 int arg2 ;
25688 wxDateSpan *result;
25689 PyObject * obj0 = 0 ;
25690 PyObject * obj1 = 0 ;
25691 char *kwnames[] = {
25692 (char *) "self",(char *) "factor", NULL
25693 };
25694
25695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25697 if (SWIG_arg_fail(1)) SWIG_fail;
25698 {
25699 arg2 = (int)(SWIG_As_int(obj1));
25700 if (SWIG_arg_fail(2)) SWIG_fail;
25701 }
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 {
25705 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25706 result = (wxDateSpan *) &_result_ref;
25707 }
25708
25709 wxPyEndAllowThreads(__tstate);
25710 if (PyErr_Occurred()) SWIG_fail;
25711 }
25712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25720 PyObject *resultobj;
25721 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25722 wxDateSpan *arg2 = 0 ;
25723 wxDateSpan result;
25724 PyObject * obj0 = 0 ;
25725 PyObject * obj1 = 0 ;
25726 char *kwnames[] = {
25727 (char *) "self",(char *) "other", NULL
25728 };
25729
25730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25732 if (SWIG_arg_fail(1)) SWIG_fail;
25733 {
25734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(2)) SWIG_fail;
25736 if (arg2 == NULL) {
25737 SWIG_null_ref("wxDateSpan");
25738 }
25739 if (SWIG_arg_fail(2)) SWIG_fail;
25740 }
25741 {
25742 PyThreadState* __tstate = wxPyBeginAllowThreads();
25743 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25744
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 {
25749 wxDateSpan * resultptr;
25750 resultptr = new wxDateSpan((wxDateSpan &)(result));
25751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25752 }
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25760 PyObject *resultobj;
25761 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25762 wxDateSpan *arg2 = 0 ;
25763 wxDateSpan result;
25764 PyObject * obj0 = 0 ;
25765 PyObject * obj1 = 0 ;
25766 char *kwnames[] = {
25767 (char *) "self",(char *) "other", NULL
25768 };
25769
25770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25772 if (SWIG_arg_fail(1)) SWIG_fail;
25773 {
25774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25775 if (SWIG_arg_fail(2)) SWIG_fail;
25776 if (arg2 == NULL) {
25777 SWIG_null_ref("wxDateSpan");
25778 }
25779 if (SWIG_arg_fail(2)) SWIG_fail;
25780 }
25781 {
25782 PyThreadState* __tstate = wxPyBeginAllowThreads();
25783 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25784
25785 wxPyEndAllowThreads(__tstate);
25786 if (PyErr_Occurred()) SWIG_fail;
25787 }
25788 {
25789 wxDateSpan * resultptr;
25790 resultptr = new wxDateSpan((wxDateSpan &)(result));
25791 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25792 }
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj;
25801 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25802 int arg2 ;
25803 wxDateSpan result;
25804 PyObject * obj0 = 0 ;
25805 PyObject * obj1 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self",(char *) "n", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(1)) SWIG_fail;
25813 {
25814 arg2 = (int)(SWIG_As_int(obj1));
25815 if (SWIG_arg_fail(2)) SWIG_fail;
25816 }
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 result = wxDateSpan___mul__(arg1,arg2);
25820
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 {
25825 wxDateSpan * resultptr;
25826 resultptr = new wxDateSpan((wxDateSpan &)(result));
25827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25828 }
25829 return resultobj;
25830 fail:
25831 return NULL;
25832 }
25833
25834
25835 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj;
25837 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25838 int arg2 ;
25839 wxDateSpan result;
25840 PyObject * obj0 = 0 ;
25841 PyObject * obj1 = 0 ;
25842 char *kwnames[] = {
25843 (char *) "self",(char *) "n", NULL
25844 };
25845
25846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25848 if (SWIG_arg_fail(1)) SWIG_fail;
25849 {
25850 arg2 = (int)(SWIG_As_int(obj1));
25851 if (SWIG_arg_fail(2)) SWIG_fail;
25852 }
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 result = wxDateSpan___rmul__(arg1,arg2);
25856
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 {
25861 wxDateSpan * resultptr;
25862 resultptr = new wxDateSpan((wxDateSpan &)(result));
25863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25864 }
25865 return resultobj;
25866 fail:
25867 return NULL;
25868 }
25869
25870
25871 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25872 PyObject *resultobj;
25873 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25874 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25875 bool result;
25876 PyObject * obj0 = 0 ;
25877 PyObject * obj1 = 0 ;
25878 char *kwnames[] = {
25879 (char *) "self",(char *) "other", NULL
25880 };
25881
25882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25884 if (SWIG_arg_fail(1)) SWIG_fail;
25885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25886 if (SWIG_arg_fail(2)) SWIG_fail;
25887 {
25888 PyThreadState* __tstate = wxPyBeginAllowThreads();
25889 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25890
25891 wxPyEndAllowThreads(__tstate);
25892 if (PyErr_Occurred()) SWIG_fail;
25893 }
25894 {
25895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25896 }
25897 return resultobj;
25898 fail:
25899 return NULL;
25900 }
25901
25902
25903 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25904 PyObject *resultobj;
25905 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25906 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25907 bool result;
25908 PyObject * obj0 = 0 ;
25909 PyObject * obj1 = 0 ;
25910 char *kwnames[] = {
25911 (char *) "self",(char *) "other", NULL
25912 };
25913
25914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25916 if (SWIG_arg_fail(1)) SWIG_fail;
25917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25918 if (SWIG_arg_fail(2)) SWIG_fail;
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25922
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 {
25927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25928 }
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25936 PyObject *obj;
25937 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25938 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25939 Py_INCREF(obj);
25940 return Py_BuildValue((char *)"");
25941 }
25942 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj;
25944 long result;
25945 char *kwnames[] = {
25946 NULL
25947 };
25948
25949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (long)wxGetLocalTime();
25953
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 {
25958 resultobj = SWIG_From_long((long)(result));
25959 }
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25967 PyObject *resultobj;
25968 long result;
25969 char *kwnames[] = {
25970 NULL
25971 };
25972
25973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 result = (long)wxGetUTCTime();
25977
25978 wxPyEndAllowThreads(__tstate);
25979 if (PyErr_Occurred()) SWIG_fail;
25980 }
25981 {
25982 resultobj = SWIG_From_long((long)(result));
25983 }
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
25991 PyObject *resultobj;
25992 long result;
25993 char *kwnames[] = {
25994 NULL
25995 };
25996
25997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
25998 {
25999 PyThreadState* __tstate = wxPyBeginAllowThreads();
26000 result = (long)wxGetCurrentTime();
26001
26002 wxPyEndAllowThreads(__tstate);
26003 if (PyErr_Occurred()) SWIG_fail;
26004 }
26005 {
26006 resultobj = SWIG_From_long((long)(result));
26007 }
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26015 PyObject *resultobj;
26016 wxLongLong result;
26017 char *kwnames[] = {
26018 NULL
26019 };
26020
26021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26022 {
26023 PyThreadState* __tstate = wxPyBeginAllowThreads();
26024 result = wxGetLocalTimeMillis();
26025
26026 wxPyEndAllowThreads(__tstate);
26027 if (PyErr_Occurred()) SWIG_fail;
26028 }
26029 {
26030 PyObject *hi, *lo, *shifter, *shifted;
26031 hi = PyLong_FromLong( (&result)->GetHi() );
26032 lo = PyLong_FromLong( (&result)->GetLo() );
26033 shifter = PyLong_FromLong(32);
26034 shifted = PyNumber_Lshift(hi, shifter);
26035 resultobj = PyNumber_Or(shifted, lo);
26036 Py_DECREF(hi);
26037 Py_DECREF(lo);
26038 Py_DECREF(shifter);
26039 Py_DECREF(shifted);
26040 }
26041 return resultobj;
26042 fail:
26043 return NULL;
26044 }
26045
26046
26047 static int _wrap_DefaultDateTime_set(PyObject *) {
26048 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26049 return 1;
26050 }
26051
26052
26053 static PyObject *_wrap_DefaultDateTime_get(void) {
26054 PyObject *pyobj;
26055
26056 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26057 return pyobj;
26058 }
26059
26060
26061 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26062 PyObject *resultobj;
26063 wxDataFormatId arg1 ;
26064 wxDataFormat *result;
26065 PyObject * obj0 = 0 ;
26066 char *kwnames[] = {
26067 (char *) "type", NULL
26068 };
26069
26070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26071 {
26072 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26073 if (SWIG_arg_fail(1)) SWIG_fail;
26074 }
26075 {
26076 PyThreadState* __tstate = wxPyBeginAllowThreads();
26077 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26078
26079 wxPyEndAllowThreads(__tstate);
26080 if (PyErr_Occurred()) SWIG_fail;
26081 }
26082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26090 PyObject *resultobj;
26091 wxString *arg1 = 0 ;
26092 wxDataFormat *result;
26093 bool temp1 = false ;
26094 PyObject * obj0 = 0 ;
26095 char *kwnames[] = {
26096 (char *) "format", NULL
26097 };
26098
26099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26100 {
26101 arg1 = wxString_in_helper(obj0);
26102 if (arg1 == NULL) SWIG_fail;
26103 temp1 = true;
26104 }
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26108
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26113 {
26114 if (temp1)
26115 delete arg1;
26116 }
26117 return resultobj;
26118 fail:
26119 {
26120 if (temp1)
26121 delete arg1;
26122 }
26123 return NULL;
26124 }
26125
26126
26127 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj;
26129 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26130 PyObject * obj0 = 0 ;
26131 char *kwnames[] = {
26132 (char *) "self", NULL
26133 };
26134
26135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26137 if (SWIG_arg_fail(1)) SWIG_fail;
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 delete arg1;
26141
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 Py_INCREF(Py_None); resultobj = Py_None;
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26153 PyObject *resultobj;
26154 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26155 wxDataFormatId arg2 ;
26156 bool result;
26157 PyObject * obj0 = 0 ;
26158 PyObject * obj1 = 0 ;
26159
26160 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26162 if (SWIG_arg_fail(1)) SWIG_fail;
26163 {
26164 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26165 if (SWIG_arg_fail(2)) SWIG_fail;
26166 }
26167 {
26168 PyThreadState* __tstate = wxPyBeginAllowThreads();
26169 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26170
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 {
26175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26176 }
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26184 PyObject *resultobj;
26185 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26186 wxDataFormatId arg2 ;
26187 bool result;
26188 PyObject * obj0 = 0 ;
26189 PyObject * obj1 = 0 ;
26190
26191 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26193 if (SWIG_arg_fail(1)) SWIG_fail;
26194 {
26195 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26196 if (SWIG_arg_fail(2)) SWIG_fail;
26197 }
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26201
26202 wxPyEndAllowThreads(__tstate);
26203 if (PyErr_Occurred()) SWIG_fail;
26204 }
26205 {
26206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26207 }
26208 return resultobj;
26209 fail:
26210 return NULL;
26211 }
26212
26213
26214 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26215 PyObject *resultobj;
26216 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26217 wxDataFormat *arg2 = 0 ;
26218 bool result;
26219 PyObject * obj0 = 0 ;
26220 PyObject * obj1 = 0 ;
26221
26222 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26224 if (SWIG_arg_fail(1)) SWIG_fail;
26225 {
26226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26227 if (SWIG_arg_fail(2)) SWIG_fail;
26228 if (arg2 == NULL) {
26229 SWIG_null_ref("wxDataFormat");
26230 }
26231 if (SWIG_arg_fail(2)) SWIG_fail;
26232 }
26233 {
26234 PyThreadState* __tstate = wxPyBeginAllowThreads();
26235 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26236
26237 wxPyEndAllowThreads(__tstate);
26238 if (PyErr_Occurred()) SWIG_fail;
26239 }
26240 {
26241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26250 int argc;
26251 PyObject *argv[3];
26252 int ii;
26253
26254 argc = PyObject_Length(args);
26255 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26256 argv[ii] = PyTuple_GetItem(args,ii);
26257 }
26258 if (argc == 2) {
26259 int _v;
26260 {
26261 void *ptr;
26262 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26263 _v = 0;
26264 PyErr_Clear();
26265 } else {
26266 _v = 1;
26267 }
26268 }
26269 if (_v) {
26270 {
26271 void *ptr = 0;
26272 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26273 _v = 0;
26274 PyErr_Clear();
26275 } else {
26276 _v = (ptr != 0);
26277 }
26278 }
26279 if (_v) {
26280 return _wrap_DataFormat___eq____SWIG_1(self,args);
26281 }
26282 }
26283 }
26284 if (argc == 2) {
26285 int _v;
26286 {
26287 void *ptr;
26288 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26289 _v = 0;
26290 PyErr_Clear();
26291 } else {
26292 _v = 1;
26293 }
26294 }
26295 if (_v) {
26296 _v = SWIG_Check_int(argv[1]);
26297 if (_v) {
26298 return _wrap_DataFormat___eq____SWIG_0(self,args);
26299 }
26300 }
26301 }
26302
26303 Py_INCREF(Py_NotImplemented);
26304 return Py_NotImplemented;
26305 }
26306
26307
26308 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26309 PyObject *resultobj;
26310 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26311 wxDataFormat *arg2 = 0 ;
26312 bool result;
26313 PyObject * obj0 = 0 ;
26314 PyObject * obj1 = 0 ;
26315
26316 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26318 if (SWIG_arg_fail(1)) SWIG_fail;
26319 {
26320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26321 if (SWIG_arg_fail(2)) SWIG_fail;
26322 if (arg2 == NULL) {
26323 SWIG_null_ref("wxDataFormat");
26324 }
26325 if (SWIG_arg_fail(2)) SWIG_fail;
26326 }
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 {
26335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26336 }
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26344 int argc;
26345 PyObject *argv[3];
26346 int ii;
26347
26348 argc = PyObject_Length(args);
26349 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26350 argv[ii] = PyTuple_GetItem(args,ii);
26351 }
26352 if (argc == 2) {
26353 int _v;
26354 {
26355 void *ptr;
26356 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26357 _v = 0;
26358 PyErr_Clear();
26359 } else {
26360 _v = 1;
26361 }
26362 }
26363 if (_v) {
26364 {
26365 void *ptr = 0;
26366 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26367 _v = 0;
26368 PyErr_Clear();
26369 } else {
26370 _v = (ptr != 0);
26371 }
26372 }
26373 if (_v) {
26374 return _wrap_DataFormat___ne____SWIG_1(self,args);
26375 }
26376 }
26377 }
26378 if (argc == 2) {
26379 int _v;
26380 {
26381 void *ptr;
26382 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26383 _v = 0;
26384 PyErr_Clear();
26385 } else {
26386 _v = 1;
26387 }
26388 }
26389 if (_v) {
26390 _v = SWIG_Check_int(argv[1]);
26391 if (_v) {
26392 return _wrap_DataFormat___ne____SWIG_0(self,args);
26393 }
26394 }
26395 }
26396
26397 Py_INCREF(Py_NotImplemented);
26398 return Py_NotImplemented;
26399 }
26400
26401
26402 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26403 PyObject *resultobj;
26404 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26405 wxDataFormatId arg2 ;
26406 PyObject * obj0 = 0 ;
26407 PyObject * obj1 = 0 ;
26408 char *kwnames[] = {
26409 (char *) "self",(char *) "format", NULL
26410 };
26411
26412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26414 if (SWIG_arg_fail(1)) SWIG_fail;
26415 {
26416 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26417 if (SWIG_arg_fail(2)) SWIG_fail;
26418 }
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 (arg1)->SetType((wxDataFormatId )arg2);
26422
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 Py_INCREF(Py_None); resultobj = Py_None;
26427 return resultobj;
26428 fail:
26429 return NULL;
26430 }
26431
26432
26433 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj;
26435 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26436 wxDataFormatId result;
26437 PyObject * obj0 = 0 ;
26438 char *kwnames[] = {
26439 (char *) "self", NULL
26440 };
26441
26442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26444 if (SWIG_arg_fail(1)) SWIG_fail;
26445 {
26446 PyThreadState* __tstate = wxPyBeginAllowThreads();
26447 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26448
26449 wxPyEndAllowThreads(__tstate);
26450 if (PyErr_Occurred()) SWIG_fail;
26451 }
26452 resultobj = SWIG_From_int((result));
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj;
26461 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26462 wxString result;
26463 PyObject * obj0 = 0 ;
26464 char *kwnames[] = {
26465 (char *) "self", NULL
26466 };
26467
26468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26470 if (SWIG_arg_fail(1)) SWIG_fail;
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 result = ((wxDataFormat const *)arg1)->GetId();
26474
26475 wxPyEndAllowThreads(__tstate);
26476 if (PyErr_Occurred()) SWIG_fail;
26477 }
26478 {
26479 #if wxUSE_UNICODE
26480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26481 #else
26482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26483 #endif
26484 }
26485 return resultobj;
26486 fail:
26487 return NULL;
26488 }
26489
26490
26491 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26492 PyObject *resultobj;
26493 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26494 wxString *arg2 = 0 ;
26495 bool temp2 = false ;
26496 PyObject * obj0 = 0 ;
26497 PyObject * obj1 = 0 ;
26498 char *kwnames[] = {
26499 (char *) "self",(char *) "format", NULL
26500 };
26501
26502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26504 if (SWIG_arg_fail(1)) SWIG_fail;
26505 {
26506 arg2 = wxString_in_helper(obj1);
26507 if (arg2 == NULL) SWIG_fail;
26508 temp2 = true;
26509 }
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 (arg1)->SetId((wxString const &)*arg2);
26513
26514 wxPyEndAllowThreads(__tstate);
26515 if (PyErr_Occurred()) SWIG_fail;
26516 }
26517 Py_INCREF(Py_None); resultobj = Py_None;
26518 {
26519 if (temp2)
26520 delete arg2;
26521 }
26522 return resultobj;
26523 fail:
26524 {
26525 if (temp2)
26526 delete arg2;
26527 }
26528 return NULL;
26529 }
26530
26531
26532 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26533 PyObject *obj;
26534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26535 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26536 Py_INCREF(obj);
26537 return Py_BuildValue((char *)"");
26538 }
26539 static int _wrap_FormatInvalid_set(PyObject *) {
26540 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26541 return 1;
26542 }
26543
26544
26545 static PyObject *_wrap_FormatInvalid_get(void) {
26546 PyObject *pyobj;
26547
26548 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26549 return pyobj;
26550 }
26551
26552
26553 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj;
26555 wxDataObject *arg1 = (wxDataObject *) 0 ;
26556 PyObject * obj0 = 0 ;
26557 char *kwnames[] = {
26558 (char *) "self", NULL
26559 };
26560
26561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26563 if (SWIG_arg_fail(1)) SWIG_fail;
26564 {
26565 PyThreadState* __tstate = wxPyBeginAllowThreads();
26566 delete arg1;
26567
26568 wxPyEndAllowThreads(__tstate);
26569 if (PyErr_Occurred()) SWIG_fail;
26570 }
26571 Py_INCREF(Py_None); resultobj = Py_None;
26572 return resultobj;
26573 fail:
26574 return NULL;
26575 }
26576
26577
26578 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26579 PyObject *resultobj;
26580 wxDataObject *arg1 = (wxDataObject *) 0 ;
26581 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26582 SwigValueWrapper<wxDataFormat > result;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char *kwnames[] = {
26586 (char *) "self",(char *) "dir", NULL
26587 };
26588
26589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26591 if (SWIG_arg_fail(1)) SWIG_fail;
26592 if (obj1) {
26593 {
26594 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26595 if (SWIG_arg_fail(2)) SWIG_fail;
26596 }
26597 }
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26601
26602 wxPyEndAllowThreads(__tstate);
26603 if (PyErr_Occurred()) SWIG_fail;
26604 }
26605 {
26606 wxDataFormat * resultptr;
26607 resultptr = new wxDataFormat((wxDataFormat &)(result));
26608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26609 }
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj;
26618 wxDataObject *arg1 = (wxDataObject *) 0 ;
26619 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26620 size_t result;
26621 PyObject * obj0 = 0 ;
26622 PyObject * obj1 = 0 ;
26623 char *kwnames[] = {
26624 (char *) "self",(char *) "dir", NULL
26625 };
26626
26627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26629 if (SWIG_arg_fail(1)) SWIG_fail;
26630 if (obj1) {
26631 {
26632 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26633 if (SWIG_arg_fail(2)) SWIG_fail;
26634 }
26635 }
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26639
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 {
26644 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26645 }
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26653 PyObject *resultobj;
26654 wxDataObject *arg1 = (wxDataObject *) 0 ;
26655 wxDataFormat *arg2 = 0 ;
26656 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26657 bool result;
26658 PyObject * obj0 = 0 ;
26659 PyObject * obj1 = 0 ;
26660 PyObject * obj2 = 0 ;
26661 char *kwnames[] = {
26662 (char *) "self",(char *) "format",(char *) "dir", NULL
26663 };
26664
26665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26667 if (SWIG_arg_fail(1)) SWIG_fail;
26668 {
26669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(2)) SWIG_fail;
26671 if (arg2 == NULL) {
26672 SWIG_null_ref("wxDataFormat");
26673 }
26674 if (SWIG_arg_fail(2)) SWIG_fail;
26675 }
26676 if (obj2) {
26677 {
26678 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26679 if (SWIG_arg_fail(3)) SWIG_fail;
26680 }
26681 }
26682 {
26683 PyThreadState* __tstate = wxPyBeginAllowThreads();
26684 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26685
26686 wxPyEndAllowThreads(__tstate);
26687 if (PyErr_Occurred()) SWIG_fail;
26688 }
26689 {
26690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26691 }
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26699 PyObject *resultobj;
26700 wxDataObject *arg1 = (wxDataObject *) 0 ;
26701 wxDataFormat *arg2 = 0 ;
26702 size_t result;
26703 PyObject * obj0 = 0 ;
26704 PyObject * obj1 = 0 ;
26705 char *kwnames[] = {
26706 (char *) "self",(char *) "format", NULL
26707 };
26708
26709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26711 if (SWIG_arg_fail(1)) SWIG_fail;
26712 {
26713 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26714 if (SWIG_arg_fail(2)) SWIG_fail;
26715 if (arg2 == NULL) {
26716 SWIG_null_ref("wxDataFormat");
26717 }
26718 if (SWIG_arg_fail(2)) SWIG_fail;
26719 }
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 {
26728 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26729 }
26730 return resultobj;
26731 fail:
26732 return NULL;
26733 }
26734
26735
26736 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26737 PyObject *resultobj;
26738 wxDataObject *arg1 = (wxDataObject *) 0 ;
26739 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26740 PyObject *result;
26741 PyObject * obj0 = 0 ;
26742 PyObject * obj1 = 0 ;
26743 char *kwnames[] = {
26744 (char *) "self",(char *) "dir", NULL
26745 };
26746
26747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26749 if (SWIG_arg_fail(1)) SWIG_fail;
26750 if (obj1) {
26751 {
26752 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26753 if (SWIG_arg_fail(2)) SWIG_fail;
26754 }
26755 }
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26759
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = result;
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj;
26772 wxDataObject *arg1 = (wxDataObject *) 0 ;
26773 wxDataFormat *arg2 = 0 ;
26774 PyObject *result;
26775 PyObject * obj0 = 0 ;
26776 PyObject * obj1 = 0 ;
26777 char *kwnames[] = {
26778 (char *) "self",(char *) "format", NULL
26779 };
26780
26781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26783 if (SWIG_arg_fail(1)) SWIG_fail;
26784 {
26785 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26786 if (SWIG_arg_fail(2)) SWIG_fail;
26787 if (arg2 == NULL) {
26788 SWIG_null_ref("wxDataFormat");
26789 }
26790 if (SWIG_arg_fail(2)) SWIG_fail;
26791 }
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26795
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 resultobj = result;
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj;
26808 wxDataObject *arg1 = (wxDataObject *) 0 ;
26809 wxDataFormat *arg2 = 0 ;
26810 PyObject *arg3 = (PyObject *) 0 ;
26811 bool result;
26812 PyObject * obj0 = 0 ;
26813 PyObject * obj1 = 0 ;
26814 PyObject * obj2 = 0 ;
26815 char *kwnames[] = {
26816 (char *) "self",(char *) "format",(char *) "data", NULL
26817 };
26818
26819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26821 if (SWIG_arg_fail(1)) SWIG_fail;
26822 {
26823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26824 if (SWIG_arg_fail(2)) SWIG_fail;
26825 if (arg2 == NULL) {
26826 SWIG_null_ref("wxDataFormat");
26827 }
26828 if (SWIG_arg_fail(2)) SWIG_fail;
26829 }
26830 arg3 = obj2;
26831 {
26832 PyThreadState* __tstate = wxPyBeginAllowThreads();
26833 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26834
26835 wxPyEndAllowThreads(__tstate);
26836 if (PyErr_Occurred()) SWIG_fail;
26837 }
26838 {
26839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26840 }
26841 return resultobj;
26842 fail:
26843 return NULL;
26844 }
26845
26846
26847 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26848 PyObject *obj;
26849 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26850 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26851 Py_INCREF(obj);
26852 return Py_BuildValue((char *)"");
26853 }
26854 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj;
26856 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26857 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26858 wxDataObjectSimple *result;
26859 PyObject * obj0 = 0 ;
26860 char *kwnames[] = {
26861 (char *) "format", NULL
26862 };
26863
26864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26865 if (obj0) {
26866 {
26867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26868 if (SWIG_arg_fail(1)) SWIG_fail;
26869 if (arg1 == NULL) {
26870 SWIG_null_ref("wxDataFormat");
26871 }
26872 if (SWIG_arg_fail(1)) SWIG_fail;
26873 }
26874 }
26875 {
26876 PyThreadState* __tstate = wxPyBeginAllowThreads();
26877 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26878
26879 wxPyEndAllowThreads(__tstate);
26880 if (PyErr_Occurred()) SWIG_fail;
26881 }
26882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26883 return resultobj;
26884 fail:
26885 return NULL;
26886 }
26887
26888
26889 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26890 PyObject *resultobj;
26891 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26892 wxDataFormat *result;
26893 PyObject * obj0 = 0 ;
26894 char *kwnames[] = {
26895 (char *) "self", NULL
26896 };
26897
26898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
26899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26900 if (SWIG_arg_fail(1)) SWIG_fail;
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 {
26904 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26905 result = (wxDataFormat *) &_result_ref;
26906 }
26907
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj;
26920 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26921 wxDataFormat *arg2 = 0 ;
26922 PyObject * obj0 = 0 ;
26923 PyObject * obj1 = 0 ;
26924 char *kwnames[] = {
26925 (char *) "self",(char *) "format", NULL
26926 };
26927
26928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26930 if (SWIG_arg_fail(1)) SWIG_fail;
26931 {
26932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26933 if (SWIG_arg_fail(2)) SWIG_fail;
26934 if (arg2 == NULL) {
26935 SWIG_null_ref("wxDataFormat");
26936 }
26937 if (SWIG_arg_fail(2)) SWIG_fail;
26938 }
26939 {
26940 PyThreadState* __tstate = wxPyBeginAllowThreads();
26941 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26942
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 Py_INCREF(Py_None); resultobj = Py_None;
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26956 size_t result;
26957 PyObject * obj0 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 {
26973 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26984 PyObject *result;
26985 PyObject * obj0 = 0 ;
26986 char *kwnames[] = {
26987 (char *) "self", NULL
26988 };
26989
26990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
26991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26992 if (SWIG_arg_fail(1)) SWIG_fail;
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
26996
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 resultobj = result;
27001 return resultobj;
27002 fail:
27003 return NULL;
27004 }
27005
27006
27007 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27008 PyObject *resultobj;
27009 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27010 PyObject *arg2 = (PyObject *) 0 ;
27011 bool result;
27012 PyObject * obj0 = 0 ;
27013 PyObject * obj1 = 0 ;
27014 char *kwnames[] = {
27015 (char *) "self",(char *) "data", NULL
27016 };
27017
27018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27020 if (SWIG_arg_fail(1)) SWIG_fail;
27021 arg2 = obj1;
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27025
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 {
27030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27031 }
27032 return resultobj;
27033 fail:
27034 return NULL;
27035 }
27036
27037
27038 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27039 PyObject *obj;
27040 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27041 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27042 Py_INCREF(obj);
27043 return Py_BuildValue((char *)"");
27044 }
27045 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj;
27047 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27048 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27049 wxPyDataObjectSimple *result;
27050 PyObject * obj0 = 0 ;
27051 char *kwnames[] = {
27052 (char *) "format", NULL
27053 };
27054
27055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27056 if (obj0) {
27057 {
27058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27059 if (SWIG_arg_fail(1)) SWIG_fail;
27060 if (arg1 == NULL) {
27061 SWIG_null_ref("wxDataFormat");
27062 }
27063 if (SWIG_arg_fail(1)) SWIG_fail;
27064 }
27065 }
27066 {
27067 PyThreadState* __tstate = wxPyBeginAllowThreads();
27068 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27069
27070 wxPyEndAllowThreads(__tstate);
27071 if (PyErr_Occurred()) SWIG_fail;
27072 }
27073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27074 return resultobj;
27075 fail:
27076 return NULL;
27077 }
27078
27079
27080 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27081 PyObject *resultobj;
27082 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27083 PyObject *arg2 = (PyObject *) 0 ;
27084 PyObject *arg3 = (PyObject *) 0 ;
27085 PyObject * obj0 = 0 ;
27086 PyObject * obj1 = 0 ;
27087 PyObject * obj2 = 0 ;
27088 char *kwnames[] = {
27089 (char *) "self",(char *) "self",(char *) "_class", NULL
27090 };
27091
27092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27094 if (SWIG_arg_fail(1)) SWIG_fail;
27095 arg2 = obj1;
27096 arg3 = obj2;
27097 {
27098 PyThreadState* __tstate = wxPyBeginAllowThreads();
27099 (arg1)->_setCallbackInfo(arg2,arg3);
27100
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 Py_INCREF(Py_None); resultobj = Py_None;
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27112 PyObject *obj;
27113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27114 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27115 Py_INCREF(obj);
27116 return Py_BuildValue((char *)"");
27117 }
27118 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27119 PyObject *resultobj;
27120 wxDataObjectComposite *result;
27121 char *kwnames[] = {
27122 NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27129
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27143 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27144 bool arg3 = (bool) false ;
27145 PyObject * obj0 = 0 ;
27146 PyObject * obj1 = 0 ;
27147 PyObject * obj2 = 0 ;
27148 char *kwnames[] = {
27149 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27150 };
27151
27152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27154 if (SWIG_arg_fail(1)) SWIG_fail;
27155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 if (obj2) {
27158 {
27159 arg3 = (bool)(SWIG_As_bool(obj2));
27160 if (SWIG_arg_fail(3)) SWIG_fail;
27161 }
27162 }
27163 {
27164 PyThreadState* __tstate = wxPyBeginAllowThreads();
27165 (arg1)->Add(arg2,arg3);
27166
27167 wxPyEndAllowThreads(__tstate);
27168 if (PyErr_Occurred()) SWIG_fail;
27169 }
27170 Py_INCREF(Py_None); resultobj = Py_None;
27171 return resultobj;
27172 fail:
27173 return NULL;
27174 }
27175
27176
27177 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27178 PyObject *obj;
27179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27180 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27181 Py_INCREF(obj);
27182 return Py_BuildValue((char *)"");
27183 }
27184 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxString const &arg1_defvalue = wxPyEmptyString ;
27187 wxString *arg1 = (wxString *) &arg1_defvalue ;
27188 wxTextDataObject *result;
27189 bool temp1 = false ;
27190 PyObject * obj0 = 0 ;
27191 char *kwnames[] = {
27192 (char *) "text", NULL
27193 };
27194
27195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27196 if (obj0) {
27197 {
27198 arg1 = wxString_in_helper(obj0);
27199 if (arg1 == NULL) SWIG_fail;
27200 temp1 = true;
27201 }
27202 }
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27206
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27211 {
27212 if (temp1)
27213 delete arg1;
27214 }
27215 return resultobj;
27216 fail:
27217 {
27218 if (temp1)
27219 delete arg1;
27220 }
27221 return NULL;
27222 }
27223
27224
27225 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27226 PyObject *resultobj;
27227 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27228 size_t result;
27229 PyObject * obj0 = 0 ;
27230 char *kwnames[] = {
27231 (char *) "self", NULL
27232 };
27233
27234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27236 if (SWIG_arg_fail(1)) SWIG_fail;
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 result = (size_t)(arg1)->GetTextLength();
27240
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 {
27245 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27246 }
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27256 wxString result;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 result = (arg1)->GetText();
27268
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 #if wxUSE_UNICODE
27274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27275 #else
27276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27277 #endif
27278 }
27279 return resultobj;
27280 fail:
27281 return NULL;
27282 }
27283
27284
27285 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27286 PyObject *resultobj;
27287 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27288 wxString *arg2 = 0 ;
27289 bool temp2 = false ;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self",(char *) "text", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 arg2 = wxString_in_helper(obj1);
27301 if (arg2 == NULL) SWIG_fail;
27302 temp2 = true;
27303 }
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 (arg1)->SetText((wxString const &)*arg2);
27307
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 Py_INCREF(Py_None); resultobj = Py_None;
27312 {
27313 if (temp2)
27314 delete arg2;
27315 }
27316 return resultobj;
27317 fail:
27318 {
27319 if (temp2)
27320 delete arg2;
27321 }
27322 return NULL;
27323 }
27324
27325
27326 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27327 PyObject *obj;
27328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27329 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27330 Py_INCREF(obj);
27331 return Py_BuildValue((char *)"");
27332 }
27333 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27334 PyObject *resultobj;
27335 wxString const &arg1_defvalue = wxPyEmptyString ;
27336 wxString *arg1 = (wxString *) &arg1_defvalue ;
27337 wxPyTextDataObject *result;
27338 bool temp1 = false ;
27339 PyObject * obj0 = 0 ;
27340 char *kwnames[] = {
27341 (char *) "text", NULL
27342 };
27343
27344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27345 if (obj0) {
27346 {
27347 arg1 = wxString_in_helper(obj0);
27348 if (arg1 == NULL) SWIG_fail;
27349 temp1 = true;
27350 }
27351 }
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27355
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27360 {
27361 if (temp1)
27362 delete arg1;
27363 }
27364 return resultobj;
27365 fail:
27366 {
27367 if (temp1)
27368 delete arg1;
27369 }
27370 return NULL;
27371 }
27372
27373
27374 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj;
27376 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27377 PyObject *arg2 = (PyObject *) 0 ;
27378 PyObject *arg3 = (PyObject *) 0 ;
27379 PyObject * obj0 = 0 ;
27380 PyObject * obj1 = 0 ;
27381 PyObject * obj2 = 0 ;
27382 char *kwnames[] = {
27383 (char *) "self",(char *) "self",(char *) "_class", NULL
27384 };
27385
27386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27388 if (SWIG_arg_fail(1)) SWIG_fail;
27389 arg2 = obj1;
27390 arg3 = obj2;
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 (arg1)->_setCallbackInfo(arg2,arg3);
27394
27395 wxPyEndAllowThreads(__tstate);
27396 if (PyErr_Occurred()) SWIG_fail;
27397 }
27398 Py_INCREF(Py_None); resultobj = Py_None;
27399 return resultobj;
27400 fail:
27401 return NULL;
27402 }
27403
27404
27405 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27406 PyObject *obj;
27407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27408 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27409 Py_INCREF(obj);
27410 return Py_BuildValue((char *)"");
27411 }
27412 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj;
27414 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27415 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27416 wxBitmapDataObject *result;
27417 PyObject * obj0 = 0 ;
27418 char *kwnames[] = {
27419 (char *) "bitmap", NULL
27420 };
27421
27422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27423 if (obj0) {
27424 {
27425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27426 if (SWIG_arg_fail(1)) SWIG_fail;
27427 if (arg1 == NULL) {
27428 SWIG_null_ref("wxBitmap");
27429 }
27430 if (SWIG_arg_fail(1)) SWIG_fail;
27431 }
27432 }
27433 {
27434 PyThreadState* __tstate = wxPyBeginAllowThreads();
27435 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27436
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27448 PyObject *resultobj;
27449 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27450 wxBitmap result;
27451 PyObject * obj0 = 0 ;
27452 char *kwnames[] = {
27453 (char *) "self", NULL
27454 };
27455
27456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27458 if (SWIG_arg_fail(1)) SWIG_fail;
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27462
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 {
27467 wxBitmap * resultptr;
27468 resultptr = new wxBitmap((wxBitmap &)(result));
27469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27470 }
27471 return resultobj;
27472 fail:
27473 return NULL;
27474 }
27475
27476
27477 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27478 PyObject *resultobj;
27479 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27480 wxBitmap *arg2 = 0 ;
27481 PyObject * obj0 = 0 ;
27482 PyObject * obj1 = 0 ;
27483 char *kwnames[] = {
27484 (char *) "self",(char *) "bitmap", NULL
27485 };
27486
27487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27489 if (SWIG_arg_fail(1)) SWIG_fail;
27490 {
27491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27492 if (SWIG_arg_fail(2)) SWIG_fail;
27493 if (arg2 == NULL) {
27494 SWIG_null_ref("wxBitmap");
27495 }
27496 if (SWIG_arg_fail(2)) SWIG_fail;
27497 }
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27501
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 Py_INCREF(Py_None); resultobj = Py_None;
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27513 PyObject *obj;
27514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27515 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27516 Py_INCREF(obj);
27517 return Py_BuildValue((char *)"");
27518 }
27519 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27520 PyObject *resultobj;
27521 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27522 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27523 wxPyBitmapDataObject *result;
27524 PyObject * obj0 = 0 ;
27525 char *kwnames[] = {
27526 (char *) "bitmap", NULL
27527 };
27528
27529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27530 if (obj0) {
27531 {
27532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27533 if (SWIG_arg_fail(1)) SWIG_fail;
27534 if (arg1 == NULL) {
27535 SWIG_null_ref("wxBitmap");
27536 }
27537 if (SWIG_arg_fail(1)) SWIG_fail;
27538 }
27539 }
27540 {
27541 PyThreadState* __tstate = wxPyBeginAllowThreads();
27542 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27543
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj;
27556 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27557 PyObject *arg2 = (PyObject *) 0 ;
27558 PyObject *arg3 = (PyObject *) 0 ;
27559 PyObject * obj0 = 0 ;
27560 PyObject * obj1 = 0 ;
27561 PyObject * obj2 = 0 ;
27562 char *kwnames[] = {
27563 (char *) "self",(char *) "self",(char *) "_class", NULL
27564 };
27565
27566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27568 if (SWIG_arg_fail(1)) SWIG_fail;
27569 arg2 = obj1;
27570 arg3 = obj2;
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 (arg1)->_setCallbackInfo(arg2,arg3);
27574
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 Py_INCREF(Py_None); resultobj = Py_None;
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27586 PyObject *obj;
27587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27588 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27589 Py_INCREF(obj);
27590 return Py_BuildValue((char *)"");
27591 }
27592 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27593 PyObject *resultobj;
27594 wxFileDataObject *result;
27595 char *kwnames[] = {
27596 NULL
27597 };
27598
27599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27600 {
27601 PyThreadState* __tstate = wxPyBeginAllowThreads();
27602 result = (wxFileDataObject *)new wxFileDataObject();
27603
27604 wxPyEndAllowThreads(__tstate);
27605 if (PyErr_Occurred()) SWIG_fail;
27606 }
27607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27608 return resultobj;
27609 fail:
27610 return NULL;
27611 }
27612
27613
27614 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27615 PyObject *resultobj;
27616 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27617 wxArrayString *result;
27618 PyObject * obj0 = 0 ;
27619 char *kwnames[] = {
27620 (char *) "self", NULL
27621 };
27622
27623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27625 if (SWIG_arg_fail(1)) SWIG_fail;
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 {
27629 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27630 result = (wxArrayString *) &_result_ref;
27631 }
27632
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 {
27637 resultobj = wxArrayString2PyList_helper(*result);
27638 }
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27646 PyObject *resultobj;
27647 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27648 wxString *arg2 = 0 ;
27649 bool temp2 = false ;
27650 PyObject * obj0 = 0 ;
27651 PyObject * obj1 = 0 ;
27652 char *kwnames[] = {
27653 (char *) "self",(char *) "filename", NULL
27654 };
27655
27656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27658 if (SWIG_arg_fail(1)) SWIG_fail;
27659 {
27660 arg2 = wxString_in_helper(obj1);
27661 if (arg2 == NULL) SWIG_fail;
27662 temp2 = true;
27663 }
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 (arg1)->AddFile((wxString const &)*arg2);
27667
27668 wxPyEndAllowThreads(__tstate);
27669 if (PyErr_Occurred()) SWIG_fail;
27670 }
27671 Py_INCREF(Py_None); resultobj = Py_None;
27672 {
27673 if (temp2)
27674 delete arg2;
27675 }
27676 return resultobj;
27677 fail:
27678 {
27679 if (temp2)
27680 delete arg2;
27681 }
27682 return NULL;
27683 }
27684
27685
27686 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27687 PyObject *obj;
27688 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27689 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27690 Py_INCREF(obj);
27691 return Py_BuildValue((char *)"");
27692 }
27693 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27694 PyObject *resultobj;
27695 wxDataFormat *arg1 = 0 ;
27696 wxCustomDataObject *result;
27697 PyObject * obj0 = 0 ;
27698
27699 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27700 {
27701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27702 if (SWIG_arg_fail(1)) SWIG_fail;
27703 if (arg1 == NULL) {
27704 SWIG_null_ref("wxDataFormat");
27705 }
27706 if (SWIG_arg_fail(1)) SWIG_fail;
27707 }
27708 {
27709 PyThreadState* __tstate = wxPyBeginAllowThreads();
27710 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27711
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27723 PyObject *resultobj;
27724 wxString *arg1 = 0 ;
27725 wxCustomDataObject *result;
27726 bool temp1 = false ;
27727 PyObject * obj0 = 0 ;
27728
27729 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27730 {
27731 arg1 = wxString_in_helper(obj0);
27732 if (arg1 == NULL) SWIG_fail;
27733 temp1 = true;
27734 }
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27738
27739 wxPyEndAllowThreads(__tstate);
27740 if (PyErr_Occurred()) SWIG_fail;
27741 }
27742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27743 {
27744 if (temp1)
27745 delete arg1;
27746 }
27747 return resultobj;
27748 fail:
27749 {
27750 if (temp1)
27751 delete arg1;
27752 }
27753 return NULL;
27754 }
27755
27756
27757 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27758 PyObject *resultobj;
27759 wxCustomDataObject *result;
27760
27761 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 result = (wxCustomDataObject *)new wxCustomDataObject();
27765
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27777 int argc;
27778 PyObject *argv[2];
27779 int ii;
27780
27781 argc = PyObject_Length(args);
27782 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27783 argv[ii] = PyTuple_GetItem(args,ii);
27784 }
27785 if (argc == 0) {
27786 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27787 }
27788 if (argc == 1) {
27789 int _v;
27790 {
27791 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27792 }
27793 if (_v) {
27794 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27795 }
27796 }
27797 if (argc == 1) {
27798 int _v;
27799 {
27800 void *ptr = 0;
27801 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27802 _v = 0;
27803 PyErr_Clear();
27804 } else {
27805 _v = (ptr != 0);
27806 }
27807 }
27808 if (_v) {
27809 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27810 }
27811 }
27812
27813 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27814 return NULL;
27815 }
27816
27817
27818 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27819 PyObject *resultobj;
27820 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27821 PyObject *arg2 = (PyObject *) 0 ;
27822 bool result;
27823 PyObject * obj0 = 0 ;
27824 PyObject * obj1 = 0 ;
27825 char *kwnames[] = {
27826 (char *) "self",(char *) "data", NULL
27827 };
27828
27829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27831 if (SWIG_arg_fail(1)) SWIG_fail;
27832 arg2 = obj1;
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27836
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 {
27841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27842 }
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27850 PyObject *resultobj;
27851 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27852 size_t result;
27853 PyObject * obj0 = 0 ;
27854 char *kwnames[] = {
27855 (char *) "self", NULL
27856 };
27857
27858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27860 if (SWIG_arg_fail(1)) SWIG_fail;
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (size_t)(arg1)->GetSize();
27864
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 {
27869 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27870 }
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27878 PyObject *resultobj;
27879 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27880 PyObject *result;
27881 PyObject * obj0 = 0 ;
27882 char *kwnames[] = {
27883 (char *) "self", NULL
27884 };
27885
27886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27888 if (SWIG_arg_fail(1)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 resultobj = result;
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27904 PyObject *obj;
27905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27906 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27907 Py_INCREF(obj);
27908 return Py_BuildValue((char *)"");
27909 }
27910 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj;
27912 wxURLDataObject *result;
27913 char *kwnames[] = {
27914 NULL
27915 };
27916
27917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27918 {
27919 PyThreadState* __tstate = wxPyBeginAllowThreads();
27920 result = (wxURLDataObject *)new wxURLDataObject();
27921
27922 wxPyEndAllowThreads(__tstate);
27923 if (PyErr_Occurred()) SWIG_fail;
27924 }
27925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj;
27934 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27935 wxString result;
27936 PyObject * obj0 = 0 ;
27937 char *kwnames[] = {
27938 (char *) "self", NULL
27939 };
27940
27941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27943 if (SWIG_arg_fail(1)) SWIG_fail;
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (arg1)->GetURL();
27947
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 {
27952 #if wxUSE_UNICODE
27953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27954 #else
27955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27956 #endif
27957 }
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj;
27966 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27967 wxString *arg2 = 0 ;
27968 bool temp2 = false ;
27969 PyObject * obj0 = 0 ;
27970 PyObject * obj1 = 0 ;
27971 char *kwnames[] = {
27972 (char *) "self",(char *) "url", NULL
27973 };
27974
27975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27977 if (SWIG_arg_fail(1)) SWIG_fail;
27978 {
27979 arg2 = wxString_in_helper(obj1);
27980 if (arg2 == NULL) SWIG_fail;
27981 temp2 = true;
27982 }
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 (arg1)->SetURL((wxString const &)*arg2);
27986
27987 wxPyEndAllowThreads(__tstate);
27988 if (PyErr_Occurred()) SWIG_fail;
27989 }
27990 Py_INCREF(Py_None); resultobj = Py_None;
27991 {
27992 if (temp2)
27993 delete arg2;
27994 }
27995 return resultobj;
27996 fail:
27997 {
27998 if (temp2)
27999 delete arg2;
28000 }
28001 return NULL;
28002 }
28003
28004
28005 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28006 PyObject *obj;
28007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28008 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28009 Py_INCREF(obj);
28010 return Py_BuildValue((char *)"");
28011 }
28012 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28013 PyObject *resultobj;
28014 wxMetafileDataObject *result;
28015 char *kwnames[] = {
28016 NULL
28017 };
28018
28019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28020 {
28021 PyThreadState* __tstate = wxPyBeginAllowThreads();
28022 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28023
28024 wxPyEndAllowThreads(__tstate);
28025 if (PyErr_Occurred()) SWIG_fail;
28026 }
28027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28028 return resultobj;
28029 fail:
28030 return NULL;
28031 }
28032
28033
28034 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28035 PyObject *resultobj;
28036 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28037 wxMetafile *arg2 = 0 ;
28038 PyObject * obj0 = 0 ;
28039 PyObject * obj1 = 0 ;
28040 char *kwnames[] = {
28041 (char *) "self",(char *) "metafile", NULL
28042 };
28043
28044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28046 if (SWIG_arg_fail(1)) SWIG_fail;
28047 {
28048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28049 if (SWIG_arg_fail(2)) SWIG_fail;
28050 if (arg2 == NULL) {
28051 SWIG_null_ref("wxMetafile");
28052 }
28053 if (SWIG_arg_fail(2)) SWIG_fail;
28054 }
28055 {
28056 PyThreadState* __tstate = wxPyBeginAllowThreads();
28057 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28058
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 Py_INCREF(Py_None); resultobj = Py_None;
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj;
28071 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28072 wxMetafile result;
28073 PyObject * obj0 = 0 ;
28074 char *kwnames[] = {
28075 (char *) "self", NULL
28076 };
28077
28078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28080 if (SWIG_arg_fail(1)) SWIG_fail;
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28084
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 {
28089 wxMetafile * resultptr;
28090 resultptr = new wxMetafile((wxMetafile &)(result));
28091 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28092 }
28093 return resultobj;
28094 fail:
28095 return NULL;
28096 }
28097
28098
28099 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28100 PyObject *obj;
28101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28102 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28103 Py_INCREF(obj);
28104 return Py_BuildValue((char *)"");
28105 }
28106 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj;
28108 wxDragResult arg1 ;
28109 bool result;
28110 PyObject * obj0 = 0 ;
28111 char *kwnames[] = {
28112 (char *) "res", NULL
28113 };
28114
28115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28116 {
28117 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28118 if (SWIG_arg_fail(1)) SWIG_fail;
28119 }
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28129 }
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28137 PyObject *resultobj;
28138 wxWindow *arg1 = (wxWindow *) 0 ;
28139 wxCursor const &arg2_defvalue = wxNullCursor ;
28140 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28141 wxCursor const &arg3_defvalue = wxNullCursor ;
28142 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28143 wxCursor const &arg4_defvalue = wxNullCursor ;
28144 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28145 wxPyDropSource *result;
28146 PyObject * obj0 = 0 ;
28147 PyObject * obj1 = 0 ;
28148 PyObject * obj2 = 0 ;
28149 PyObject * obj3 = 0 ;
28150 char *kwnames[] = {
28151 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28152 };
28153
28154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28156 if (SWIG_arg_fail(1)) SWIG_fail;
28157 if (obj1) {
28158 {
28159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28160 if (SWIG_arg_fail(2)) SWIG_fail;
28161 if (arg2 == NULL) {
28162 SWIG_null_ref("wxCursor");
28163 }
28164 if (SWIG_arg_fail(2)) SWIG_fail;
28165 }
28166 }
28167 if (obj2) {
28168 {
28169 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28170 if (SWIG_arg_fail(3)) SWIG_fail;
28171 if (arg3 == NULL) {
28172 SWIG_null_ref("wxCursor");
28173 }
28174 if (SWIG_arg_fail(3)) SWIG_fail;
28175 }
28176 }
28177 if (obj3) {
28178 {
28179 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28180 if (SWIG_arg_fail(4)) SWIG_fail;
28181 if (arg4 == NULL) {
28182 SWIG_null_ref("wxCursor");
28183 }
28184 if (SWIG_arg_fail(4)) SWIG_fail;
28185 }
28186 }
28187 {
28188 PyThreadState* __tstate = wxPyBeginAllowThreads();
28189 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28190
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28195 return resultobj;
28196 fail:
28197 return NULL;
28198 }
28199
28200
28201 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28202 PyObject *resultobj;
28203 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28204 PyObject *arg2 = (PyObject *) 0 ;
28205 PyObject *arg3 = (PyObject *) 0 ;
28206 int arg4 ;
28207 PyObject * obj0 = 0 ;
28208 PyObject * obj1 = 0 ;
28209 PyObject * obj2 = 0 ;
28210 PyObject * obj3 = 0 ;
28211 char *kwnames[] = {
28212 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28213 };
28214
28215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28217 if (SWIG_arg_fail(1)) SWIG_fail;
28218 arg2 = obj1;
28219 arg3 = obj2;
28220 {
28221 arg4 = (int)(SWIG_As_int(obj3));
28222 if (SWIG_arg_fail(4)) SWIG_fail;
28223 }
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28227
28228 wxPyEndAllowThreads(__tstate);
28229 if (PyErr_Occurred()) SWIG_fail;
28230 }
28231 Py_INCREF(Py_None); resultobj = Py_None;
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj;
28240 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28241 PyObject * obj0 = 0 ;
28242 char *kwnames[] = {
28243 (char *) "self", NULL
28244 };
28245
28246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28248 if (SWIG_arg_fail(1)) SWIG_fail;
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 delete arg1;
28252
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 Py_INCREF(Py_None); resultobj = Py_None;
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj;
28265 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28266 wxDataObject *arg2 = 0 ;
28267 PyObject * obj0 = 0 ;
28268 PyObject * obj1 = 0 ;
28269 char *kwnames[] = {
28270 (char *) "self",(char *) "data", NULL
28271 };
28272
28273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28275 if (SWIG_arg_fail(1)) SWIG_fail;
28276 {
28277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28278 if (SWIG_arg_fail(2)) SWIG_fail;
28279 if (arg2 == NULL) {
28280 SWIG_null_ref("wxDataObject");
28281 }
28282 if (SWIG_arg_fail(2)) SWIG_fail;
28283 }
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 (arg1)->SetData(*arg2);
28287
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 Py_INCREF(Py_None); resultobj = Py_None;
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj;
28300 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28301 wxDataObject *result;
28302 PyObject * obj0 = 0 ;
28303 char *kwnames[] = {
28304 (char *) "self", NULL
28305 };
28306
28307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28309 if (SWIG_arg_fail(1)) SWIG_fail;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (wxDataObject *)(arg1)->GetDataObject();
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28325 PyObject *resultobj;
28326 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28327 wxDragResult arg2 ;
28328 wxCursor *arg3 = 0 ;
28329 PyObject * obj0 = 0 ;
28330 PyObject * obj1 = 0 ;
28331 PyObject * obj2 = 0 ;
28332 char *kwnames[] = {
28333 (char *) "self",(char *) "res",(char *) "cursor", NULL
28334 };
28335
28336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(1)) SWIG_fail;
28339 {
28340 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28341 if (SWIG_arg_fail(2)) SWIG_fail;
28342 }
28343 {
28344 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28345 if (SWIG_arg_fail(3)) SWIG_fail;
28346 if (arg3 == NULL) {
28347 SWIG_null_ref("wxCursor");
28348 }
28349 if (SWIG_arg_fail(3)) SWIG_fail;
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28354
28355 wxPyEndAllowThreads(__tstate);
28356 if (PyErr_Occurred()) SWIG_fail;
28357 }
28358 Py_INCREF(Py_None); resultobj = Py_None;
28359 return resultobj;
28360 fail:
28361 return NULL;
28362 }
28363
28364
28365 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28368 int arg2 = (int) wxDrag_CopyOnly ;
28369 wxDragResult result;
28370 PyObject * obj0 = 0 ;
28371 PyObject * obj1 = 0 ;
28372 char *kwnames[] = {
28373 (char *) "self",(char *) "flags", NULL
28374 };
28375
28376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28378 if (SWIG_arg_fail(1)) SWIG_fail;
28379 if (obj1) {
28380 {
28381 arg2 = (int)(SWIG_As_int(obj1));
28382 if (SWIG_arg_fail(2)) SWIG_fail;
28383 }
28384 }
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28388
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 resultobj = SWIG_From_int((result));
28393 return resultobj;
28394 fail:
28395 return NULL;
28396 }
28397
28398
28399 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28400 PyObject *resultobj;
28401 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28402 wxDragResult arg2 ;
28403 bool result;
28404 PyObject * obj0 = 0 ;
28405 PyObject * obj1 = 0 ;
28406 char *kwnames[] = {
28407 (char *) "self",(char *) "effect", NULL
28408 };
28409
28410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28412 if (SWIG_arg_fail(1)) SWIG_fail;
28413 {
28414 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28415 if (SWIG_arg_fail(2)) SWIG_fail;
28416 }
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28420
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 {
28425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28426 }
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28434 PyObject *obj;
28435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28436 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28437 Py_INCREF(obj);
28438 return Py_BuildValue((char *)"");
28439 }
28440 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28441 PyObject *resultobj;
28442 wxDataObject *arg1 = (wxDataObject *) NULL ;
28443 wxPyDropTarget *result;
28444 PyObject * obj0 = 0 ;
28445 char *kwnames[] = {
28446 (char *) "dataObject", NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28450 if (obj0) {
28451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28452 if (SWIG_arg_fail(1)) SWIG_fail;
28453 }
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj;
28470 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28471 PyObject *arg2 = (PyObject *) 0 ;
28472 PyObject *arg3 = (PyObject *) 0 ;
28473 PyObject * obj0 = 0 ;
28474 PyObject * obj1 = 0 ;
28475 PyObject * obj2 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "self",(char *) "self",(char *) "_class", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 arg2 = obj1;
28484 arg3 = obj2;
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 (arg1)->_setCallbackInfo(arg2,arg3);
28488
28489 wxPyEndAllowThreads(__tstate);
28490 if (PyErr_Occurred()) SWIG_fail;
28491 }
28492 Py_INCREF(Py_None); resultobj = Py_None;
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28500 PyObject *resultobj;
28501 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28502 PyObject * obj0 = 0 ;
28503 char *kwnames[] = {
28504 (char *) "self", NULL
28505 };
28506
28507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28509 if (SWIG_arg_fail(1)) SWIG_fail;
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 delete arg1;
28513
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 Py_INCREF(Py_None); resultobj = Py_None;
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28525 PyObject *resultobj;
28526 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28527 wxDataObject *result;
28528 PyObject * obj0 = 0 ;
28529 char *kwnames[] = {
28530 (char *) "self", NULL
28531 };
28532
28533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28535 if (SWIG_arg_fail(1)) SWIG_fail;
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 result = (wxDataObject *)(arg1)->GetDataObject();
28539
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj;
28552 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28553 wxDataObject *arg2 = (wxDataObject *) 0 ;
28554 PyObject * obj0 = 0 ;
28555 PyObject * obj1 = 0 ;
28556 char *kwnames[] = {
28557 (char *) "self",(char *) "dataObject", NULL
28558 };
28559
28560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28562 if (SWIG_arg_fail(1)) SWIG_fail;
28563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28564 if (SWIG_arg_fail(2)) SWIG_fail;
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 (arg1)->SetDataObject(arg2);
28568
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 Py_INCREF(Py_None); resultobj = Py_None;
28573 return resultobj;
28574 fail:
28575 return NULL;
28576 }
28577
28578
28579 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28580 PyObject *resultobj;
28581 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28582 int arg2 ;
28583 int arg3 ;
28584 wxDragResult arg4 ;
28585 wxDragResult result;
28586 PyObject * obj0 = 0 ;
28587 PyObject * obj1 = 0 ;
28588 PyObject * obj2 = 0 ;
28589 PyObject * obj3 = 0 ;
28590 char *kwnames[] = {
28591 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28592 };
28593
28594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28596 if (SWIG_arg_fail(1)) SWIG_fail;
28597 {
28598 arg2 = (int)(SWIG_As_int(obj1));
28599 if (SWIG_arg_fail(2)) SWIG_fail;
28600 }
28601 {
28602 arg3 = (int)(SWIG_As_int(obj2));
28603 if (SWIG_arg_fail(3)) SWIG_fail;
28604 }
28605 {
28606 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28607 if (SWIG_arg_fail(4)) SWIG_fail;
28608 }
28609 {
28610 PyThreadState* __tstate = wxPyBeginAllowThreads();
28611 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28612
28613 wxPyEndAllowThreads(__tstate);
28614 if (PyErr_Occurred()) SWIG_fail;
28615 }
28616 resultobj = SWIG_From_int((result));
28617 return resultobj;
28618 fail:
28619 return NULL;
28620 }
28621
28622
28623 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28624 PyObject *resultobj;
28625 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28626 int arg2 ;
28627 int arg3 ;
28628 wxDragResult arg4 ;
28629 wxDragResult result;
28630 PyObject * obj0 = 0 ;
28631 PyObject * obj1 = 0 ;
28632 PyObject * obj2 = 0 ;
28633 PyObject * obj3 = 0 ;
28634 char *kwnames[] = {
28635 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28636 };
28637
28638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28640 if (SWIG_arg_fail(1)) SWIG_fail;
28641 {
28642 arg2 = (int)(SWIG_As_int(obj1));
28643 if (SWIG_arg_fail(2)) SWIG_fail;
28644 }
28645 {
28646 arg3 = (int)(SWIG_As_int(obj2));
28647 if (SWIG_arg_fail(3)) SWIG_fail;
28648 }
28649 {
28650 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28651 if (SWIG_arg_fail(4)) SWIG_fail;
28652 }
28653 {
28654 PyThreadState* __tstate = wxPyBeginAllowThreads();
28655 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28656
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_From_int((result));
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28668 PyObject *resultobj;
28669 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28670 PyObject * obj0 = 0 ;
28671 char *kwnames[] = {
28672 (char *) "self", NULL
28673 };
28674
28675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28677 if (SWIG_arg_fail(1)) SWIG_fail;
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 (arg1)->base_OnLeave();
28681
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 Py_INCREF(Py_None); resultobj = Py_None;
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28693 PyObject *resultobj;
28694 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28695 int arg2 ;
28696 int arg3 ;
28697 bool result;
28698 PyObject * obj0 = 0 ;
28699 PyObject * obj1 = 0 ;
28700 PyObject * obj2 = 0 ;
28701 char *kwnames[] = {
28702 (char *) "self",(char *) "x",(char *) "y", NULL
28703 };
28704
28705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28707 if (SWIG_arg_fail(1)) SWIG_fail;
28708 {
28709 arg2 = (int)(SWIG_As_int(obj1));
28710 if (SWIG_arg_fail(2)) SWIG_fail;
28711 }
28712 {
28713 arg3 = (int)(SWIG_As_int(obj2));
28714 if (SWIG_arg_fail(3)) SWIG_fail;
28715 }
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28719
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 {
28724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28725 }
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28733 PyObject *resultobj;
28734 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28735 bool result;
28736 PyObject * obj0 = 0 ;
28737 char *kwnames[] = {
28738 (char *) "self", NULL
28739 };
28740
28741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28743 if (SWIG_arg_fail(1)) SWIG_fail;
28744 {
28745 PyThreadState* __tstate = wxPyBeginAllowThreads();
28746 result = (bool)(arg1)->GetData();
28747
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 {
28752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28753 }
28754 return resultobj;
28755 fail:
28756 return NULL;
28757 }
28758
28759
28760 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28761 PyObject *obj;
28762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28763 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28764 Py_INCREF(obj);
28765 return Py_BuildValue((char *)"");
28766 }
28767 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28768 PyObject *resultobj;
28769 wxPyTextDropTarget *result;
28770 char *kwnames[] = {
28771 NULL
28772 };
28773
28774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28778
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj;
28791 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28792 PyObject *arg2 = (PyObject *) 0 ;
28793 PyObject *arg3 = (PyObject *) 0 ;
28794 PyObject * obj0 = 0 ;
28795 PyObject * obj1 = 0 ;
28796 PyObject * obj2 = 0 ;
28797 char *kwnames[] = {
28798 (char *) "self",(char *) "self",(char *) "_class", NULL
28799 };
28800
28801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(1)) SWIG_fail;
28804 arg2 = obj1;
28805 arg3 = obj2;
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 (arg1)->_setCallbackInfo(arg2,arg3);
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 Py_INCREF(Py_None); resultobj = Py_None;
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj;
28822 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28823 int arg2 ;
28824 int arg3 ;
28825 wxDragResult arg4 ;
28826 wxDragResult result;
28827 PyObject * obj0 = 0 ;
28828 PyObject * obj1 = 0 ;
28829 PyObject * obj2 = 0 ;
28830 PyObject * obj3 = 0 ;
28831 char *kwnames[] = {
28832 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28833 };
28834
28835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28837 if (SWIG_arg_fail(1)) SWIG_fail;
28838 {
28839 arg2 = (int)(SWIG_As_int(obj1));
28840 if (SWIG_arg_fail(2)) SWIG_fail;
28841 }
28842 {
28843 arg3 = (int)(SWIG_As_int(obj2));
28844 if (SWIG_arg_fail(3)) SWIG_fail;
28845 }
28846 {
28847 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28848 if (SWIG_arg_fail(4)) SWIG_fail;
28849 }
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28853
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 resultobj = SWIG_From_int((result));
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj;
28866 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28867 int arg2 ;
28868 int arg3 ;
28869 wxDragResult arg4 ;
28870 wxDragResult result;
28871 PyObject * obj0 = 0 ;
28872 PyObject * obj1 = 0 ;
28873 PyObject * obj2 = 0 ;
28874 PyObject * obj3 = 0 ;
28875 char *kwnames[] = {
28876 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28877 };
28878
28879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, 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 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28892 if (SWIG_arg_fail(4)) SWIG_fail;
28893 }
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28897
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 resultobj = SWIG_From_int((result));
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28909 PyObject *resultobj;
28910 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28911 PyObject * obj0 = 0 ;
28912 char *kwnames[] = {
28913 (char *) "self", NULL
28914 };
28915
28916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28918 if (SWIG_arg_fail(1)) SWIG_fail;
28919 {
28920 PyThreadState* __tstate = wxPyBeginAllowThreads();
28921 (arg1)->base_OnLeave();
28922
28923 wxPyEndAllowThreads(__tstate);
28924 if (PyErr_Occurred()) SWIG_fail;
28925 }
28926 Py_INCREF(Py_None); resultobj = Py_None;
28927 return resultobj;
28928 fail:
28929 return NULL;
28930 }
28931
28932
28933 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28934 PyObject *resultobj;
28935 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28936 int arg2 ;
28937 int arg3 ;
28938 bool result;
28939 PyObject * obj0 = 0 ;
28940 PyObject * obj1 = 0 ;
28941 PyObject * obj2 = 0 ;
28942 char *kwnames[] = {
28943 (char *) "self",(char *) "x",(char *) "y", NULL
28944 };
28945
28946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28948 if (SWIG_arg_fail(1)) SWIG_fail;
28949 {
28950 arg2 = (int)(SWIG_As_int(obj1));
28951 if (SWIG_arg_fail(2)) SWIG_fail;
28952 }
28953 {
28954 arg3 = (int)(SWIG_As_int(obj2));
28955 if (SWIG_arg_fail(3)) SWIG_fail;
28956 }
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28960
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 {
28965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28966 }
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28976 int arg2 ;
28977 int arg3 ;
28978 wxDragResult arg4 ;
28979 wxDragResult result;
28980 PyObject * obj0 = 0 ;
28981 PyObject * obj1 = 0 ;
28982 PyObject * obj2 = 0 ;
28983 PyObject * obj3 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 arg2 = (int)(SWIG_As_int(obj1));
28993 if (SWIG_arg_fail(2)) SWIG_fail;
28994 }
28995 {
28996 arg3 = (int)(SWIG_As_int(obj2));
28997 if (SWIG_arg_fail(3)) SWIG_fail;
28998 }
28999 {
29000 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29001 if (SWIG_arg_fail(4)) SWIG_fail;
29002 }
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 resultobj = SWIG_From_int((result));
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29018 PyObject *obj;
29019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29020 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29021 Py_INCREF(obj);
29022 return Py_BuildValue((char *)"");
29023 }
29024 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29025 PyObject *resultobj;
29026 wxPyFileDropTarget *result;
29027 char *kwnames[] = {
29028 NULL
29029 };
29030
29031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29035
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29047 PyObject *resultobj;
29048 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29049 PyObject *arg2 = (PyObject *) 0 ;
29050 PyObject *arg3 = (PyObject *) 0 ;
29051 PyObject * obj0 = 0 ;
29052 PyObject * obj1 = 0 ;
29053 PyObject * obj2 = 0 ;
29054 char *kwnames[] = {
29055 (char *) "self",(char *) "self",(char *) "_class", NULL
29056 };
29057
29058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29060 if (SWIG_arg_fail(1)) SWIG_fail;
29061 arg2 = obj1;
29062 arg3 = obj2;
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 (arg1)->_setCallbackInfo(arg2,arg3);
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 Py_INCREF(Py_None); resultobj = Py_None;
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj;
29079 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29080 int arg2 ;
29081 int arg3 ;
29082 wxDragResult arg4 ;
29083 wxDragResult result;
29084 PyObject * obj0 = 0 ;
29085 PyObject * obj1 = 0 ;
29086 PyObject * obj2 = 0 ;
29087 PyObject * obj3 = 0 ;
29088 char *kwnames[] = {
29089 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29090 };
29091
29092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29094 if (SWIG_arg_fail(1)) SWIG_fail;
29095 {
29096 arg2 = (int)(SWIG_As_int(obj1));
29097 if (SWIG_arg_fail(2)) SWIG_fail;
29098 }
29099 {
29100 arg3 = (int)(SWIG_As_int(obj2));
29101 if (SWIG_arg_fail(3)) SWIG_fail;
29102 }
29103 {
29104 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29105 if (SWIG_arg_fail(4)) SWIG_fail;
29106 }
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_From_int((result));
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj;
29123 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29124 int arg2 ;
29125 int arg3 ;
29126 wxDragResult arg4 ;
29127 wxDragResult result;
29128 PyObject * obj0 = 0 ;
29129 PyObject * obj1 = 0 ;
29130 PyObject * obj2 = 0 ;
29131 PyObject * obj3 = 0 ;
29132 char *kwnames[] = {
29133 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29134 };
29135
29136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29138 if (SWIG_arg_fail(1)) SWIG_fail;
29139 {
29140 arg2 = (int)(SWIG_As_int(obj1));
29141 if (SWIG_arg_fail(2)) SWIG_fail;
29142 }
29143 {
29144 arg3 = (int)(SWIG_As_int(obj2));
29145 if (SWIG_arg_fail(3)) SWIG_fail;
29146 }
29147 {
29148 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29149 if (SWIG_arg_fail(4)) SWIG_fail;
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29154
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 resultobj = SWIG_From_int((result));
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29166 PyObject *resultobj;
29167 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29168 PyObject * obj0 = 0 ;
29169 char *kwnames[] = {
29170 (char *) "self", NULL
29171 };
29172
29173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29175 if (SWIG_arg_fail(1)) SWIG_fail;
29176 {
29177 PyThreadState* __tstate = wxPyBeginAllowThreads();
29178 (arg1)->base_OnLeave();
29179
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 Py_INCREF(Py_None); resultobj = Py_None;
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29191 PyObject *resultobj;
29192 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29193 int arg2 ;
29194 int arg3 ;
29195 bool result;
29196 PyObject * obj0 = 0 ;
29197 PyObject * obj1 = 0 ;
29198 PyObject * obj2 = 0 ;
29199 char *kwnames[] = {
29200 (char *) "self",(char *) "x",(char *) "y", NULL
29201 };
29202
29203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29205 if (SWIG_arg_fail(1)) SWIG_fail;
29206 {
29207 arg2 = (int)(SWIG_As_int(obj1));
29208 if (SWIG_arg_fail(2)) SWIG_fail;
29209 }
29210 {
29211 arg3 = (int)(SWIG_As_int(obj2));
29212 if (SWIG_arg_fail(3)) SWIG_fail;
29213 }
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 {
29222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29223 }
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj;
29232 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29233 int arg2 ;
29234 int arg3 ;
29235 wxDragResult arg4 ;
29236 wxDragResult result;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 PyObject * obj3 = 0 ;
29241 char *kwnames[] = {
29242 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29243 };
29244
29245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29247 if (SWIG_arg_fail(1)) SWIG_fail;
29248 {
29249 arg2 = (int)(SWIG_As_int(obj1));
29250 if (SWIG_arg_fail(2)) SWIG_fail;
29251 }
29252 {
29253 arg3 = (int)(SWIG_As_int(obj2));
29254 if (SWIG_arg_fail(3)) SWIG_fail;
29255 }
29256 {
29257 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29258 if (SWIG_arg_fail(4)) SWIG_fail;
29259 }
29260 {
29261 PyThreadState* __tstate = wxPyBeginAllowThreads();
29262 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29263
29264 wxPyEndAllowThreads(__tstate);
29265 if (PyErr_Occurred()) SWIG_fail;
29266 }
29267 resultobj = SWIG_From_int((result));
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29275 PyObject *obj;
29276 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29277 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29278 Py_INCREF(obj);
29279 return Py_BuildValue((char *)"");
29280 }
29281 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29282 PyObject *resultobj;
29283 wxClipboard *result;
29284 char *kwnames[] = {
29285 NULL
29286 };
29287
29288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 result = (wxClipboard *)new wxClipboard();
29292
29293 wxPyEndAllowThreads(__tstate);
29294 if (PyErr_Occurred()) SWIG_fail;
29295 }
29296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29297 return resultobj;
29298 fail:
29299 return NULL;
29300 }
29301
29302
29303 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29304 PyObject *resultobj;
29305 wxClipboard *arg1 = (wxClipboard *) 0 ;
29306 PyObject * obj0 = 0 ;
29307 char *kwnames[] = {
29308 (char *) "self", NULL
29309 };
29310
29311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29313 if (SWIG_arg_fail(1)) SWIG_fail;
29314 {
29315 PyThreadState* __tstate = wxPyBeginAllowThreads();
29316 delete arg1;
29317
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 Py_INCREF(Py_None); resultobj = Py_None;
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29329 PyObject *resultobj;
29330 wxClipboard *arg1 = (wxClipboard *) 0 ;
29331 bool result;
29332 PyObject * obj0 = 0 ;
29333 char *kwnames[] = {
29334 (char *) "self", NULL
29335 };
29336
29337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29339 if (SWIG_arg_fail(1)) SWIG_fail;
29340 {
29341 PyThreadState* __tstate = wxPyBeginAllowThreads();
29342 result = (bool)(arg1)->Open();
29343
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 {
29348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29349 }
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29357 PyObject *resultobj;
29358 wxClipboard *arg1 = (wxClipboard *) 0 ;
29359 PyObject * obj0 = 0 ;
29360 char *kwnames[] = {
29361 (char *) "self", NULL
29362 };
29363
29364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29366 if (SWIG_arg_fail(1)) SWIG_fail;
29367 {
29368 PyThreadState* __tstate = wxPyBeginAllowThreads();
29369 (arg1)->Close();
29370
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 Py_INCREF(Py_None); resultobj = Py_None;
29375 return resultobj;
29376 fail:
29377 return NULL;
29378 }
29379
29380
29381 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29382 PyObject *resultobj;
29383 wxClipboard *arg1 = (wxClipboard *) 0 ;
29384 bool result;
29385 PyObject * obj0 = 0 ;
29386 char *kwnames[] = {
29387 (char *) "self", NULL
29388 };
29389
29390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29392 if (SWIG_arg_fail(1)) SWIG_fail;
29393 {
29394 PyThreadState* __tstate = wxPyBeginAllowThreads();
29395 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29396
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 {
29401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29402 }
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj;
29411 wxClipboard *arg1 = (wxClipboard *) 0 ;
29412 wxDataObject *arg2 = (wxDataObject *) 0 ;
29413 bool result;
29414 PyObject * obj0 = 0 ;
29415 PyObject * obj1 = 0 ;
29416 char *kwnames[] = {
29417 (char *) "self",(char *) "data", NULL
29418 };
29419
29420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29422 if (SWIG_arg_fail(1)) SWIG_fail;
29423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29424 if (SWIG_arg_fail(2)) SWIG_fail;
29425 {
29426 PyThreadState* __tstate = wxPyBeginAllowThreads();
29427 result = (bool)(arg1)->AddData(arg2);
29428
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 {
29433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29434 }
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj;
29443 wxClipboard *arg1 = (wxClipboard *) 0 ;
29444 wxDataObject *arg2 = (wxDataObject *) 0 ;
29445 bool result;
29446 PyObject * obj0 = 0 ;
29447 PyObject * obj1 = 0 ;
29448 char *kwnames[] = {
29449 (char *) "self",(char *) "data", NULL
29450 };
29451
29452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29454 if (SWIG_arg_fail(1)) SWIG_fail;
29455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29456 if (SWIG_arg_fail(2)) SWIG_fail;
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 result = (bool)(arg1)->SetData(arg2);
29460
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 {
29465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29466 }
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29474 PyObject *resultobj;
29475 wxClipboard *arg1 = (wxClipboard *) 0 ;
29476 wxDataFormat *arg2 = 0 ;
29477 bool result;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 char *kwnames[] = {
29481 (char *) "self",(char *) "format", NULL
29482 };
29483
29484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29486 if (SWIG_arg_fail(1)) SWIG_fail;
29487 {
29488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29489 if (SWIG_arg_fail(2)) SWIG_fail;
29490 if (arg2 == NULL) {
29491 SWIG_null_ref("wxDataFormat");
29492 }
29493 if (SWIG_arg_fail(2)) SWIG_fail;
29494 }
29495 {
29496 PyThreadState* __tstate = wxPyBeginAllowThreads();
29497 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29498
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 {
29503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29504 }
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29512 PyObject *resultobj;
29513 wxClipboard *arg1 = (wxClipboard *) 0 ;
29514 wxDataObject *arg2 = 0 ;
29515 bool result;
29516 PyObject * obj0 = 0 ;
29517 PyObject * obj1 = 0 ;
29518 char *kwnames[] = {
29519 (char *) "self",(char *) "data", NULL
29520 };
29521
29522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29524 if (SWIG_arg_fail(1)) SWIG_fail;
29525 {
29526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29527 if (SWIG_arg_fail(2)) SWIG_fail;
29528 if (arg2 == NULL) {
29529 SWIG_null_ref("wxDataObject");
29530 }
29531 if (SWIG_arg_fail(2)) SWIG_fail;
29532 }
29533 {
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 result = (bool)(arg1)->GetData(*arg2);
29536
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 {
29541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29542 }
29543 return resultobj;
29544 fail:
29545 return NULL;
29546 }
29547
29548
29549 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29550 PyObject *resultobj;
29551 wxClipboard *arg1 = (wxClipboard *) 0 ;
29552 PyObject * obj0 = 0 ;
29553 char *kwnames[] = {
29554 (char *) "self", NULL
29555 };
29556
29557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29559 if (SWIG_arg_fail(1)) SWIG_fail;
29560 {
29561 PyThreadState* __tstate = wxPyBeginAllowThreads();
29562 (arg1)->Clear();
29563
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 Py_INCREF(Py_None); resultobj = Py_None;
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj;
29576 wxClipboard *arg1 = (wxClipboard *) 0 ;
29577 bool result;
29578 PyObject * obj0 = 0 ;
29579 char *kwnames[] = {
29580 (char *) "self", NULL
29581 };
29582
29583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29585 if (SWIG_arg_fail(1)) SWIG_fail;
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (bool)(arg1)->Flush();
29589
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 {
29594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29595 }
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29603 PyObject *resultobj;
29604 wxClipboard *arg1 = (wxClipboard *) 0 ;
29605 bool arg2 = (bool) true ;
29606 PyObject * obj0 = 0 ;
29607 PyObject * obj1 = 0 ;
29608 char *kwnames[] = {
29609 (char *) "self",(char *) "primary", NULL
29610 };
29611
29612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29614 if (SWIG_arg_fail(1)) SWIG_fail;
29615 if (obj1) {
29616 {
29617 arg2 = (bool)(SWIG_As_bool(obj1));
29618 if (SWIG_arg_fail(2)) SWIG_fail;
29619 }
29620 }
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 (arg1)->UsePrimarySelection(arg2);
29624
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 Py_INCREF(Py_None); resultobj = Py_None;
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29636 PyObject *resultobj;
29637 wxClipboard *result;
29638 char *kwnames[] = {
29639 NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 result = (wxClipboard *)wxClipboard::Get();
29646
29647 wxPyEndAllowThreads(__tstate);
29648 if (PyErr_Occurred()) SWIG_fail;
29649 }
29650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29651 return resultobj;
29652 fail:
29653 return NULL;
29654 }
29655
29656
29657 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29658 PyObject *obj;
29659 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29660 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29661 Py_INCREF(obj);
29662 return Py_BuildValue((char *)"");
29663 }
29664 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj;
29666 wxClipboard *arg1 = (wxClipboard *) NULL ;
29667 wxClipboardLocker *result;
29668 PyObject * obj0 = 0 ;
29669 char *kwnames[] = {
29670 (char *) "clipboard", NULL
29671 };
29672
29673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29674 if (obj0) {
29675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29676 if (SWIG_arg_fail(1)) SWIG_fail;
29677 }
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj;
29694 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29695 PyObject * obj0 = 0 ;
29696 char *kwnames[] = {
29697 (char *) "self", NULL
29698 };
29699
29700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29702 if (SWIG_arg_fail(1)) SWIG_fail;
29703 {
29704 PyThreadState* __tstate = wxPyBeginAllowThreads();
29705 delete arg1;
29706
29707 wxPyEndAllowThreads(__tstate);
29708 if (PyErr_Occurred()) SWIG_fail;
29709 }
29710 Py_INCREF(Py_None); resultobj = Py_None;
29711 return resultobj;
29712 fail:
29713 return NULL;
29714 }
29715
29716
29717 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29718 PyObject *resultobj;
29719 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29720 bool result;
29721 PyObject * obj0 = 0 ;
29722 char *kwnames[] = {
29723 (char *) "self", NULL
29724 };
29725
29726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29728 if (SWIG_arg_fail(1)) SWIG_fail;
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 result = (bool)wxClipboardLocker___nonzero__(arg1);
29732
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 {
29737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29738 }
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29746 PyObject *obj;
29747 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29748 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29749 Py_INCREF(obj);
29750 return Py_BuildValue((char *)"");
29751 }
29752 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29753 PyObject *resultobj;
29754 int arg1 = (int) 0 ;
29755 int arg2 = (int) 0 ;
29756 int arg3 = (int) 0 ;
29757 int arg4 = (int) 0 ;
29758 wxVideoMode *result;
29759 PyObject * obj0 = 0 ;
29760 PyObject * obj1 = 0 ;
29761 PyObject * obj2 = 0 ;
29762 PyObject * obj3 = 0 ;
29763 char *kwnames[] = {
29764 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29765 };
29766
29767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29768 if (obj0) {
29769 {
29770 arg1 = (int)(SWIG_As_int(obj0));
29771 if (SWIG_arg_fail(1)) SWIG_fail;
29772 }
29773 }
29774 if (obj1) {
29775 {
29776 arg2 = (int)(SWIG_As_int(obj1));
29777 if (SWIG_arg_fail(2)) SWIG_fail;
29778 }
29779 }
29780 if (obj2) {
29781 {
29782 arg3 = (int)(SWIG_As_int(obj2));
29783 if (SWIG_arg_fail(3)) SWIG_fail;
29784 }
29785 }
29786 if (obj3) {
29787 {
29788 arg4 = (int)(SWIG_As_int(obj3));
29789 if (SWIG_arg_fail(4)) SWIG_fail;
29790 }
29791 }
29792 {
29793 PyThreadState* __tstate = wxPyBeginAllowThreads();
29794 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29795
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29807 PyObject *resultobj;
29808 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29809 PyObject * obj0 = 0 ;
29810 char *kwnames[] = {
29811 (char *) "self", NULL
29812 };
29813
29814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 {
29818 PyThreadState* __tstate = wxPyBeginAllowThreads();
29819 delete arg1;
29820
29821 wxPyEndAllowThreads(__tstate);
29822 if (PyErr_Occurred()) SWIG_fail;
29823 }
29824 Py_INCREF(Py_None); resultobj = Py_None;
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29832 PyObject *resultobj;
29833 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29834 wxVideoMode *arg2 = 0 ;
29835 bool result;
29836 PyObject * obj0 = 0 ;
29837 PyObject * obj1 = 0 ;
29838 char *kwnames[] = {
29839 (char *) "self",(char *) "other", NULL
29840 };
29841
29842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29844 if (SWIG_arg_fail(1)) SWIG_fail;
29845 {
29846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29847 if (SWIG_arg_fail(2)) SWIG_fail;
29848 if (arg2 == NULL) {
29849 SWIG_null_ref("wxVideoMode");
29850 }
29851 if (SWIG_arg_fail(2)) SWIG_fail;
29852 }
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29856
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 {
29861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj;
29871 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29872 int result;
29873 PyObject * obj0 = 0 ;
29874 char *kwnames[] = {
29875 (char *) "self", NULL
29876 };
29877
29878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29880 if (SWIG_arg_fail(1)) SWIG_fail;
29881 {
29882 PyThreadState* __tstate = wxPyBeginAllowThreads();
29883 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29884
29885 wxPyEndAllowThreads(__tstate);
29886 if (PyErr_Occurred()) SWIG_fail;
29887 }
29888 {
29889 resultobj = SWIG_From_int((int)(result));
29890 }
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29898 PyObject *resultobj;
29899 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29900 int result;
29901 PyObject * obj0 = 0 ;
29902 char *kwnames[] = {
29903 (char *) "self", NULL
29904 };
29905
29906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29908 if (SWIG_arg_fail(1)) SWIG_fail;
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29912
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 {
29917 resultobj = SWIG_From_int((int)(result));
29918 }
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj;
29927 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29928 int result;
29929 PyObject * obj0 = 0 ;
29930 char *kwnames[] = {
29931 (char *) "self", NULL
29932 };
29933
29934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29936 if (SWIG_arg_fail(1)) SWIG_fail;
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 {
29945 resultobj = SWIG_From_int((int)(result));
29946 }
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj;
29955 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29956 bool result;
29957 PyObject * obj0 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29968
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 {
29973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29974 }
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29982 PyObject *resultobj;
29983 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29984 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29985 bool result;
29986 PyObject * obj0 = 0 ;
29987 PyObject * obj1 = 0 ;
29988 char *kwnames[] = {
29989 (char *) "self",(char *) "other", NULL
29990 };
29991
29992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29994 if (SWIG_arg_fail(1)) SWIG_fail;
29995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29996 if (SWIG_arg_fail(2)) SWIG_fail;
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30000
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 {
30005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30006 }
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj;
30015 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30016 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30017 bool result;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 char *kwnames[] = {
30021 (char *) "self",(char *) "other", NULL
30022 };
30023
30024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(1)) SWIG_fail;
30027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30028 if (SWIG_arg_fail(2)) SWIG_fail;
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30032
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30038 }
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30046 PyObject *resultobj;
30047 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30048 int arg2 ;
30049 PyObject * obj0 = 0 ;
30050 PyObject * obj1 = 0 ;
30051 char *kwnames[] = {
30052 (char *) "self",(char *) "w", NULL
30053 };
30054
30055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30057 if (SWIG_arg_fail(1)) SWIG_fail;
30058 {
30059 arg2 = (int)(SWIG_As_int(obj1));
30060 if (SWIG_arg_fail(2)) SWIG_fail;
30061 }
30062 if (arg1) (arg1)->w = arg2;
30063
30064 Py_INCREF(Py_None); resultobj = Py_None;
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 static PyObject *_wrap_VideoMode_w_get(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_w_get",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 result = (int) ((arg1)->w);
30084
30085 {
30086 resultobj = SWIG_From_int((int)(result));
30087 }
30088 return resultobj;
30089 fail:
30090 return NULL;
30091 }
30092
30093
30094 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30095 PyObject *resultobj;
30096 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30097 int arg2 ;
30098 PyObject * obj0 = 0 ;
30099 PyObject * obj1 = 0 ;
30100 char *kwnames[] = {
30101 (char *) "self",(char *) "h", NULL
30102 };
30103
30104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30106 if (SWIG_arg_fail(1)) SWIG_fail;
30107 {
30108 arg2 = (int)(SWIG_As_int(obj1));
30109 if (SWIG_arg_fail(2)) SWIG_fail;
30110 }
30111 if (arg1) (arg1)->h = arg2;
30112
30113 Py_INCREF(Py_None); resultobj = Py_None;
30114 return resultobj;
30115 fail:
30116 return NULL;
30117 }
30118
30119
30120 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30121 PyObject *resultobj;
30122 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30123 int result;
30124 PyObject * obj0 = 0 ;
30125 char *kwnames[] = {
30126 (char *) "self", NULL
30127 };
30128
30129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30131 if (SWIG_arg_fail(1)) SWIG_fail;
30132 result = (int) ((arg1)->h);
30133
30134 {
30135 resultobj = SWIG_From_int((int)(result));
30136 }
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30144 PyObject *resultobj;
30145 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30146 int arg2 ;
30147 PyObject * obj0 = 0 ;
30148 PyObject * obj1 = 0 ;
30149 char *kwnames[] = {
30150 (char *) "self",(char *) "bpp", NULL
30151 };
30152
30153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30155 if (SWIG_arg_fail(1)) SWIG_fail;
30156 {
30157 arg2 = (int)(SWIG_As_int(obj1));
30158 if (SWIG_arg_fail(2)) SWIG_fail;
30159 }
30160 if (arg1) (arg1)->bpp = arg2;
30161
30162 Py_INCREF(Py_None); resultobj = Py_None;
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj;
30171 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30172 int result;
30173 PyObject * obj0 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 result = (int) ((arg1)->bpp);
30182
30183 {
30184 resultobj = SWIG_From_int((int)(result));
30185 }
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30193 PyObject *resultobj;
30194 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30195 int arg2 ;
30196 PyObject * obj0 = 0 ;
30197 PyObject * obj1 = 0 ;
30198 char *kwnames[] = {
30199 (char *) "self",(char *) "refresh", NULL
30200 };
30201
30202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30204 if (SWIG_arg_fail(1)) SWIG_fail;
30205 {
30206 arg2 = (int)(SWIG_As_int(obj1));
30207 if (SWIG_arg_fail(2)) SWIG_fail;
30208 }
30209 if (arg1) (arg1)->refresh = arg2;
30210
30211 Py_INCREF(Py_None); resultobj = Py_None;
30212 return resultobj;
30213 fail:
30214 return NULL;
30215 }
30216
30217
30218 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj;
30220 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30221 int result;
30222 PyObject * obj0 = 0 ;
30223 char *kwnames[] = {
30224 (char *) "self", NULL
30225 };
30226
30227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30229 if (SWIG_arg_fail(1)) SWIG_fail;
30230 result = (int) ((arg1)->refresh);
30231
30232 {
30233 resultobj = SWIG_From_int((int)(result));
30234 }
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30242 PyObject *obj;
30243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30244 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30245 Py_INCREF(obj);
30246 return Py_BuildValue((char *)"");
30247 }
30248 static int _wrap_DefaultVideoMode_set(PyObject *) {
30249 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30250 return 1;
30251 }
30252
30253
30254 static PyObject *_wrap_DefaultVideoMode_get(void) {
30255 PyObject *pyobj;
30256
30257 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30258 return pyobj;
30259 }
30260
30261
30262 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30263 PyObject *resultobj;
30264 size_t arg1 = (size_t) 0 ;
30265 wxDisplay *result;
30266 PyObject * obj0 = 0 ;
30267 char *kwnames[] = {
30268 (char *) "index", NULL
30269 };
30270
30271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30272 if (obj0) {
30273 {
30274 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30275 if (SWIG_arg_fail(1)) SWIG_fail;
30276 }
30277 }
30278 {
30279 PyThreadState* __tstate = wxPyBeginAllowThreads();
30280 result = (wxDisplay *)new wxDisplay(arg1);
30281
30282 wxPyEndAllowThreads(__tstate);
30283 if (PyErr_Occurred()) SWIG_fail;
30284 }
30285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30293 PyObject *resultobj;
30294 wxDisplay *arg1 = (wxDisplay *) 0 ;
30295 PyObject * obj0 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "self", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30302 if (SWIG_arg_fail(1)) SWIG_fail;
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 delete arg1;
30306
30307 wxPyEndAllowThreads(__tstate);
30308 if (PyErr_Occurred()) SWIG_fail;
30309 }
30310 Py_INCREF(Py_None); resultobj = Py_None;
30311 return resultobj;
30312 fail:
30313 return NULL;
30314 }
30315
30316
30317 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30318 PyObject *resultobj;
30319 size_t result;
30320 char *kwnames[] = {
30321 NULL
30322 };
30323
30324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (size_t)wxDisplay::GetCount();
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 {
30333 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30334 }
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 wxPoint *arg1 = 0 ;
30344 int result;
30345 wxPoint temp1 ;
30346 PyObject * obj0 = 0 ;
30347 char *kwnames[] = {
30348 (char *) "pt", NULL
30349 };
30350
30351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30352 {
30353 arg1 = &temp1;
30354 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30355 }
30356 {
30357 PyThreadState* __tstate = wxPyBeginAllowThreads();
30358 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30359
30360 wxPyEndAllowThreads(__tstate);
30361 if (PyErr_Occurred()) SWIG_fail;
30362 }
30363 {
30364 resultobj = SWIG_From_int((int)(result));
30365 }
30366 return resultobj;
30367 fail:
30368 return NULL;
30369 }
30370
30371
30372 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30373 PyObject *resultobj;
30374 wxWindow *arg1 = (wxWindow *) 0 ;
30375 int result;
30376 PyObject * obj0 = 0 ;
30377 char *kwnames[] = {
30378 (char *) "window", NULL
30379 };
30380
30381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30383 if (SWIG_arg_fail(1)) SWIG_fail;
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = (int)Display_GetFromWindow(arg1);
30387
30388 wxPyEndAllowThreads(__tstate);
30389 if (PyErr_Occurred()) SWIG_fail;
30390 }
30391 {
30392 resultobj = SWIG_From_int((int)(result));
30393 }
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30401 PyObject *resultobj;
30402 wxDisplay *arg1 = (wxDisplay *) 0 ;
30403 bool result;
30404 PyObject * obj0 = 0 ;
30405 char *kwnames[] = {
30406 (char *) "self", NULL
30407 };
30408
30409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30411 if (SWIG_arg_fail(1)) SWIG_fail;
30412 {
30413 PyThreadState* __tstate = wxPyBeginAllowThreads();
30414 result = (bool)((wxDisplay const *)arg1)->IsOk();
30415
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 {
30420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30421 }
30422 return resultobj;
30423 fail:
30424 return NULL;
30425 }
30426
30427
30428 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30429 PyObject *resultobj;
30430 wxDisplay *arg1 = (wxDisplay *) 0 ;
30431 wxRect result;
30432 PyObject * obj0 = 0 ;
30433 char *kwnames[] = {
30434 (char *) "self", NULL
30435 };
30436
30437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30439 if (SWIG_arg_fail(1)) SWIG_fail;
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 result = ((wxDisplay const *)arg1)->GetGeometry();
30443
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 {
30448 wxRect * resultptr;
30449 resultptr = new wxRect((wxRect &)(result));
30450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30451 }
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj;
30460 wxDisplay *arg1 = (wxDisplay *) 0 ;
30461 wxString result;
30462 PyObject * obj0 = 0 ;
30463 char *kwnames[] = {
30464 (char *) "self", NULL
30465 };
30466
30467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(1)) SWIG_fail;
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 result = ((wxDisplay const *)arg1)->GetName();
30473
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 {
30478 #if wxUSE_UNICODE
30479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30480 #else
30481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30482 #endif
30483 }
30484 return resultobj;
30485 fail:
30486 return NULL;
30487 }
30488
30489
30490 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30491 PyObject *resultobj;
30492 wxDisplay *arg1 = (wxDisplay *) 0 ;
30493 bool result;
30494 PyObject * obj0 = 0 ;
30495 char *kwnames[] = {
30496 (char *) "self", NULL
30497 };
30498
30499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30501 if (SWIG_arg_fail(1)) SWIG_fail;
30502 {
30503 PyThreadState* __tstate = wxPyBeginAllowThreads();
30504 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30505
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 {
30510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30511 }
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj;
30520 wxDisplay *arg1 = (wxDisplay *) 0 ;
30521 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30522 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30523 PyObject *result;
30524 PyObject * obj0 = 0 ;
30525 PyObject * obj1 = 0 ;
30526 char *kwnames[] = {
30527 (char *) "self",(char *) "mode", NULL
30528 };
30529
30530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30532 if (SWIG_arg_fail(1)) SWIG_fail;
30533 if (obj1) {
30534 {
30535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30536 if (SWIG_arg_fail(2)) SWIG_fail;
30537 if (arg2 == NULL) {
30538 SWIG_null_ref("wxVideoMode");
30539 }
30540 if (SWIG_arg_fail(2)) SWIG_fail;
30541 }
30542 }
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30546
30547 wxPyEndAllowThreads(__tstate);
30548 if (PyErr_Occurred()) SWIG_fail;
30549 }
30550 resultobj = result;
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30558 PyObject *resultobj;
30559 wxDisplay *arg1 = (wxDisplay *) 0 ;
30560 wxVideoMode result;
30561 PyObject * obj0 = 0 ;
30562 char *kwnames[] = {
30563 (char *) "self", NULL
30564 };
30565
30566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30568 if (SWIG_arg_fail(1)) SWIG_fail;
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30572
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 {
30577 wxVideoMode * resultptr;
30578 resultptr = new wxVideoMode((wxVideoMode &)(result));
30579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30580 }
30581 return resultobj;
30582 fail:
30583 return NULL;
30584 }
30585
30586
30587 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30588 PyObject *resultobj;
30589 wxDisplay *arg1 = (wxDisplay *) 0 ;
30590 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30591 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30592 bool result;
30593 PyObject * obj0 = 0 ;
30594 PyObject * obj1 = 0 ;
30595 char *kwnames[] = {
30596 (char *) "self",(char *) "mode", NULL
30597 };
30598
30599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30601 if (SWIG_arg_fail(1)) SWIG_fail;
30602 if (obj1) {
30603 {
30604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30605 if (SWIG_arg_fail(2)) SWIG_fail;
30606 if (arg2 == NULL) {
30607 SWIG_null_ref("wxVideoMode");
30608 }
30609 if (SWIG_arg_fail(2)) SWIG_fail;
30610 }
30611 }
30612 {
30613 PyThreadState* __tstate = wxPyBeginAllowThreads();
30614 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30615
30616 wxPyEndAllowThreads(__tstate);
30617 if (PyErr_Occurred()) SWIG_fail;
30618 }
30619 {
30620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30621 }
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30629 PyObject *resultobj;
30630 wxDisplay *arg1 = (wxDisplay *) 0 ;
30631 PyObject * obj0 = 0 ;
30632 char *kwnames[] = {
30633 (char *) "self", NULL
30634 };
30635
30636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30638 if (SWIG_arg_fail(1)) SWIG_fail;
30639 {
30640 PyThreadState* __tstate = wxPyBeginAllowThreads();
30641 (arg1)->ResetMode();
30642
30643 wxPyEndAllowThreads(__tstate);
30644 if (PyErr_Occurred()) SWIG_fail;
30645 }
30646 Py_INCREF(Py_None); resultobj = Py_None;
30647 return resultobj;
30648 fail:
30649 return NULL;
30650 }
30651
30652
30653 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30654 PyObject *obj;
30655 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30656 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30657 Py_INCREF(obj);
30658 return Py_BuildValue((char *)"");
30659 }
30660 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj;
30662 wxStandardPaths *result;
30663 char *kwnames[] = {
30664 NULL
30665 };
30666
30667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 result = (wxStandardPaths *)StandardPaths_Get();
30671
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj;
30684 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30685 wxString result;
30686 PyObject * obj0 = 0 ;
30687 char *kwnames[] = {
30688 (char *) "self", NULL
30689 };
30690
30691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30693 if (SWIG_arg_fail(1)) SWIG_fail;
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 {
30702 #if wxUSE_UNICODE
30703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30704 #else
30705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30706 #endif
30707 }
30708 return resultobj;
30709 fail:
30710 return NULL;
30711 }
30712
30713
30714 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30715 PyObject *resultobj;
30716 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30717 wxString result;
30718 PyObject * obj0 = 0 ;
30719 char *kwnames[] = {
30720 (char *) "self", NULL
30721 };
30722
30723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30725 if (SWIG_arg_fail(1)) SWIG_fail;
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30729
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 {
30734 #if wxUSE_UNICODE
30735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30736 #else
30737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30738 #endif
30739 }
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30747 PyObject *resultobj;
30748 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30749 wxString result;
30750 PyObject * obj0 = 0 ;
30751 char *kwnames[] = {
30752 (char *) "self", NULL
30753 };
30754
30755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30757 if (SWIG_arg_fail(1)) SWIG_fail;
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30761
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 {
30766 #if wxUSE_UNICODE
30767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30768 #else
30769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30770 #endif
30771 }
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj;
30780 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30781 wxString result;
30782 PyObject * obj0 = 0 ;
30783 char *kwnames[] = {
30784 (char *) "self", NULL
30785 };
30786
30787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30789 if (SWIG_arg_fail(1)) SWIG_fail;
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 {
30798 #if wxUSE_UNICODE
30799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30800 #else
30801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30802 #endif
30803 }
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj;
30812 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30813 wxString result;
30814 PyObject * obj0 = 0 ;
30815 char *kwnames[] = {
30816 (char *) "self", NULL
30817 };
30818
30819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30821 if (SWIG_arg_fail(1)) SWIG_fail;
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30825
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 {
30830 #if wxUSE_UNICODE
30831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30832 #else
30833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30834 #endif
30835 }
30836 return resultobj;
30837 fail:
30838 return NULL;
30839 }
30840
30841
30842 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30843 PyObject *resultobj;
30844 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30845 wxString result;
30846 PyObject * obj0 = 0 ;
30847 char *kwnames[] = {
30848 (char *) "self", NULL
30849 };
30850
30851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30853 if (SWIG_arg_fail(1)) SWIG_fail;
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30857
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 {
30862 #if wxUSE_UNICODE
30863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30864 #else
30865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30866 #endif
30867 }
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30877 wxString result;
30878 PyObject * obj0 = 0 ;
30879 char *kwnames[] = {
30880 (char *) "self", NULL
30881 };
30882
30883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30885 if (SWIG_arg_fail(1)) SWIG_fail;
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30889
30890 wxPyEndAllowThreads(__tstate);
30891 if (PyErr_Occurred()) SWIG_fail;
30892 }
30893 {
30894 #if wxUSE_UNICODE
30895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30896 #else
30897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30898 #endif
30899 }
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30909 wxString *arg2 = 0 ;
30910 bool temp2 = false ;
30911 PyObject * obj0 = 0 ;
30912 PyObject * obj1 = 0 ;
30913 char *kwnames[] = {
30914 (char *) "self",(char *) "prefix", NULL
30915 };
30916
30917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30919 if (SWIG_arg_fail(1)) SWIG_fail;
30920 {
30921 arg2 = wxString_in_helper(obj1);
30922 if (arg2 == NULL) SWIG_fail;
30923 temp2 = true;
30924 }
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
30928
30929 wxPyEndAllowThreads(__tstate);
30930 if (PyErr_Occurred()) SWIG_fail;
30931 }
30932 Py_INCREF(Py_None); resultobj = Py_None;
30933 {
30934 if (temp2)
30935 delete arg2;
30936 }
30937 return resultobj;
30938 fail:
30939 {
30940 if (temp2)
30941 delete arg2;
30942 }
30943 return NULL;
30944 }
30945
30946
30947 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30948 PyObject *resultobj;
30949 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30950 wxString result;
30951 PyObject * obj0 = 0 ;
30952 char *kwnames[] = {
30953 (char *) "self", NULL
30954 };
30955
30956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30958 if (SWIG_arg_fail(1)) SWIG_fail;
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 result = wxStandardPaths_GetInstallPrefix(arg1);
30962
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 {
30967 #if wxUSE_UNICODE
30968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30969 #else
30970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30971 #endif
30972 }
30973 return resultobj;
30974 fail:
30975 return NULL;
30976 }
30977
30978
30979 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30980 PyObject *obj;
30981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30982 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30983 Py_INCREF(obj);
30984 return Py_BuildValue((char *)"");
30985 }
30986 static PyMethodDef SwigMethods[] = {
30987 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30989 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30990 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30991 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30992 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30993 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
30994 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30999 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31000 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31001 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31007 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31039 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31040 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31043 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31044 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31049 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31063 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31064 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31065 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31073 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31091 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31094 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31097 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31100 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31106 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31120 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31126 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31131 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31134 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31148 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31151 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31152 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31155 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31182 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31184 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31186 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31188 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31195 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31201 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31215 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31219 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31222 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31239 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31247 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31294 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31312 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31322 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31338 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31354 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31368 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31377 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31420 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31423 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31426 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31430 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31523 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31524 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31525 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31526 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31543 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31588 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31622 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31630 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31631 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31636 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31645 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31652 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31655 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31658 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31663 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31666 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31670 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31673 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31677 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31678 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31682 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31686 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31690 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31700 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31711 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31719 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31727 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31741 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31745 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31763 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31777 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31788 { NULL, NULL, 0, NULL }
31789 };
31790
31791
31792 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31793
31794 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31795 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31796 }
31797 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31798 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31799 }
31800 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31801 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31802 }
31803 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31804 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31805 }
31806 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31807 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31808 }
31809 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31810 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31811 }
31812 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31813 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31814 }
31815 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31816 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31817 }
31818 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31819 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31820 }
31821 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31822 return (void *)((wxEvent *) ((wxPyEvent *) x));
31823 }
31824 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31825 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31826 }
31827 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31828 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31829 }
31830 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31831 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31832 }
31833 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31834 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31835 }
31836 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31837 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31838 }
31839 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31840 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31841 }
31842 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31843 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31844 }
31845 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31846 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31847 }
31848 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31849 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31850 }
31851 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31852 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31853 }
31854 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
31855 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
31856 }
31857 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31858 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31859 }
31860 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31861 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31862 }
31863 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31864 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31865 }
31866 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31867 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31868 }
31869 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31870 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31871 }
31872 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31873 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31874 }
31875 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31876 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31877 }
31878 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31879 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31880 }
31881 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31882 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31883 }
31884 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31885 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31886 }
31887 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31888 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31889 }
31890 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31891 return (void *)((wxEvent *) ((wxShowEvent *) x));
31892 }
31893 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31894 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31895 }
31896 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31897 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31898 }
31899 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31900 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31901 }
31902 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31903 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31904 }
31905 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31906 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31907 }
31908 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31909 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31910 }
31911 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31912 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31913 }
31914 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31915 return (void *)((wxConfigBase *) ((wxConfig *) x));
31916 }
31917 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31918 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31919 }
31920 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31921 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31922 }
31923 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31924 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31925 }
31926 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31927 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31928 }
31929 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31930 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31931 }
31932 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31933 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31934 }
31935 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31936 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31937 }
31938 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31939 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31940 }
31941 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31942 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31943 }
31944 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31945 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31946 }
31947 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31948 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31949 }
31950 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31951 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31952 }
31953 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31954 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31955 }
31956 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31957 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31958 }
31959 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31960 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31961 }
31962 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31963 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31964 }
31965 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31966 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31967 }
31968 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31969 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31970 }
31971 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31972 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31973 }
31974 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31975 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31976 }
31977 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31978 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31979 }
31980 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31981 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31982 }
31983 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31984 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31985 }
31986 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31987 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31988 }
31989 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31990 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31991 }
31992 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31993 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31994 }
31995 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31996 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
31997 }
31998 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
31999 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32000 }
32001 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32002 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32003 }
32004 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32005 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32006 }
32007 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32008 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32009 }
32010 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32011 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32012 }
32013 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32014 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32015 }
32016 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32017 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32018 }
32019 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32020 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32021 }
32022 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32023 return (void *)((wxObject *) ((wxSizerItem *) x));
32024 }
32025 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32026 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32027 }
32028 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32029 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32030 }
32031 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32032 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32033 }
32034 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32035 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32036 }
32037 static void *_p_wxSizerTo_p_wxObject(void *x) {
32038 return (void *)((wxObject *) ((wxSizer *) x));
32039 }
32040 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32041 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32042 }
32043 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32044 return (void *)((wxObject *) ((wxFileHistory *) x));
32045 }
32046 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32047 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32048 }
32049 static void *_p_wxEventTo_p_wxObject(void *x) {
32050 return (void *)((wxObject *) ((wxEvent *) x));
32051 }
32052 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32053 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32054 }
32055 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32056 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32057 }
32058 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32059 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32060 }
32061 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32062 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32063 }
32064 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32065 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32066 }
32067 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32068 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32069 }
32070 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32071 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32072 }
32073 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32074 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32075 }
32076 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32077 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32078 }
32079 static void *_p_wxControlTo_p_wxObject(void *x) {
32080 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32081 }
32082 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32083 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32084 }
32085 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32086 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32087 }
32088 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32089 return (void *)((wxObject *) ((wxFSFile *) x));
32090 }
32091 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32092 return (void *)((wxObject *) ((wxClipboard *) x));
32093 }
32094 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32095 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32096 }
32097 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32098 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32099 }
32100 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32101 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32102 }
32103 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32104 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32105 }
32106 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32107 return (void *)((wxObject *) ((wxToolTip *) x));
32108 }
32109 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32110 return (void *)((wxObject *) ((wxMenuItem *) x));
32111 }
32112 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32113 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32114 }
32115 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32116 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32117 }
32118 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32119 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32120 }
32121 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32122 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32123 }
32124 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32125 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32126 }
32127 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32128 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32129 }
32130 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32131 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32132 }
32133 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32134 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32135 }
32136 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32137 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32138 }
32139 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32140 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32141 }
32142 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32143 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32144 }
32145 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32146 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32147 }
32148 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32149 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32150 }
32151 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32152 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32153 }
32154 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32155 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32156 }
32157 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32158 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32159 }
32160 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32161 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32162 }
32163 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32164 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32165 }
32166 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32167 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32168 }
32169 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32170 return (void *)((wxObject *) ((wxImageHandler *) x));
32171 }
32172 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32173 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32174 }
32175 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32176 return (void *)((wxObject *) ((wxEvtHandler *) x));
32177 }
32178 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32179 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32180 }
32181 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32182 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32183 }
32184 static void *_p_wxImageTo_p_wxObject(void *x) {
32185 return (void *)((wxObject *) ((wxImage *) x));
32186 }
32187 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32188 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32189 }
32190 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32191 return (void *)((wxObject *) ((wxSystemOptions *) x));
32192 }
32193 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32194 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32195 }
32196 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32197 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32198 }
32199 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32200 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32201 }
32202 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32203 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32204 }
32205 static void *_p_wxWindowTo_p_wxObject(void *x) {
32206 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32207 }
32208 static void *_p_wxMenuTo_p_wxObject(void *x) {
32209 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32210 }
32211 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32212 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32213 }
32214 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32215 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32216 }
32217 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32218 return (void *)((wxObject *) ((wxFileSystem *) x));
32219 }
32220 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32221 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32222 }
32223 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32224 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32225 }
32226 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32227 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32228 }
32229 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32230 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32231 }
32232 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32233 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32234 }
32235 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32236 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32237 }
32238 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32239 return (void *)((wxObject *) ((wxBusyInfo *) x));
32240 }
32241 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32242 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32243 }
32244 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32245 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32246 }
32247 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32248 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32249 }
32250 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32251 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32252 }
32253 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32255 }
32256 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32257 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32258 }
32259 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32260 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32261 }
32262 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32263 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32264 }
32265 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32266 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32267 }
32268 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32269 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32270 }
32271 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32272 return (void *)((wxLog *) ((wxLogStderr *) x));
32273 }
32274 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32275 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32276 }
32277 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32278 return (void *)((wxLog *) ((wxLogWindow *) x));
32279 }
32280 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32281 return (void *)((wxLog *) ((wxLogChain *) x));
32282 }
32283 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32284 return (void *)((wxLog *) ((wxLogGui *) x));
32285 }
32286 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32287 return (void *)((wxLog *) ((wxPyLog *) x));
32288 }
32289 static void *_p_wxControlTo_p_wxWindow(void *x) {
32290 return (void *)((wxWindow *) ((wxControl *) x));
32291 }
32292 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32293 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32294 }
32295 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32296 return (void *)((wxWindow *) ((wxMenuBar *) x));
32297 }
32298 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32299 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32300 }
32301 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32302 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32303 }
32304 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}};
32305 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}};
32306 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32307 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}};
32308 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}};
32309 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}};
32310 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}};
32311 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}};
32312 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}};
32313 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}};
32314 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}};
32315 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}};
32316 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}};
32317 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}};
32318 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}};
32319 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}};
32320 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}};
32321 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}};
32322 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}};
32323 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}};
32324 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}};
32325 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}};
32326 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}};
32327 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}};
32328 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}};
32329 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}};
32330 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}};
32331 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}};
32332 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}};
32333 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}};
32334 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}};
32335 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}};
32336 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}};
32337 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}};
32338 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}};
32339 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}};
32340 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}};
32341 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}};
32342 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}};
32343 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}};
32344 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}};
32345 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}};
32346 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}};
32347 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}};
32348 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}};
32349 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}};
32350 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}};
32351 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}};
32352 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}};
32353 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}};
32354 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}};
32355 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}};
32356 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}};
32357 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}};
32358 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}};
32359 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}};
32360 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}};
32361 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}};
32362 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}};
32363 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}};
32364 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}};
32365 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}};
32366 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}};
32367 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}};
32368 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}};
32369 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}};
32370 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}};
32371 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}};
32372 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}};
32373 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}};
32374 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}};
32375 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}};
32376 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}};
32377 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}};
32378 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}};
32379 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}};
32380 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}};
32381 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}};
32382 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}};
32383 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}};
32384 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}};
32385 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}};
32386 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}};
32387 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}};
32388 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}};
32389 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}};
32390 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}};
32391 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}};
32392 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}};
32393 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}};
32394 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}};
32395 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}};
32396 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}};
32397 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}};
32398 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}};
32399 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}};
32400
32401 static swig_type_info *swig_types_initial[] = {
32402 _swigt__p_wxLogChain,
32403 _swigt__p_wxMutexGuiLocker,
32404 _swigt__p_wxMetafile,
32405 _swigt__p_wxFileHistory,
32406 _swigt__p_wxLog,
32407 _swigt__p_wxMenu,
32408 _swigt__p_wxEvent,
32409 _swigt__p_wxDateTime__TimeZone,
32410 _swigt__p_wxConfigBase,
32411 _swigt__p_wxDisplay,
32412 _swigt__p_wxFileType,
32413 _swigt__p_wxLogGui,
32414 _swigt__p_wxFont,
32415 _swigt__p_wxDataFormat,
32416 _swigt__p_wxTimerEvent,
32417 _swigt__p_wxCaret,
32418 _swigt__ptrdiff_t,
32419 _swigt__std__ptrdiff_t,
32420 _swigt__p_int,
32421 _swigt__p_wxSize,
32422 _swigt__p_wxClipboard,
32423 _swigt__p_wxStopWatch,
32424 _swigt__p_wxClipboardLocker,
32425 _swigt__p_wxIcon,
32426 _swigt__p_wxLogStderr,
32427 _swigt__p_wxLogTextCtrl,
32428 _swigt__p_wxTextCtrl,
32429 _swigt__p_wxBusyCursor,
32430 _swigt__p_wxBitmapDataObject,
32431 _swigt__p_wxTextDataObject,
32432 _swigt__p_wxDataObject,
32433 _swigt__p_wxPyTextDataObject,
32434 _swigt__p_wxPyBitmapDataObject,
32435 _swigt__p_wxFileDataObject,
32436 _swigt__p_wxCustomDataObject,
32437 _swigt__p_wxURLDataObject,
32438 _swigt__p_wxMetafileDataObject,
32439 _swigt__p_wxSound,
32440 _swigt__p_wxTimerRunner,
32441 _swigt__p_wxLogWindow,
32442 _swigt__p_wxTimeSpan,
32443 _swigt__p_wxArrayString,
32444 _swigt__p_wxWindowDisabler,
32445 _swigt__p_form_ops_t,
32446 _swigt__p_wxToolTip,
32447 _swigt__p_wxDataObjectComposite,
32448 _swigt__p_wxFileConfig,
32449 _swigt__p_wxSystemSettings,
32450 _swigt__p_wxVideoMode,
32451 _swigt__p_wxDataObjectSimple,
32452 _swigt__p_wxPyDataObjectSimple,
32453 _swigt__p_wxDuplexMode,
32454 _swigt__p_wxEvtHandler,
32455 _swigt__p_wxRect,
32456 _swigt__p_char,
32457 _swigt__p_wxSingleInstanceChecker,
32458 _swigt__p_wxStandardPaths,
32459 _swigt__p_wxFileTypeInfo,
32460 _swigt__p_wxFrame,
32461 _swigt__p_wxTimer,
32462 _swigt__p_wxPaperSize,
32463 _swigt__p_wxMimeTypesManager,
32464 _swigt__p_wxPyArtProvider,
32465 _swigt__p_wxPyTipProvider,
32466 _swigt__p_wxTipProvider,
32467 _swigt__p_wxJoystick,
32468 _swigt__p_wxSystemOptions,
32469 _swigt__p_wxPoint,
32470 _swigt__p_wxJoystickEvent,
32471 _swigt__p_wxCursor,
32472 _swigt__p_wxObject,
32473 _swigt__p_wxOutputStream,
32474 _swigt__p_wxDateTime,
32475 _swigt__p_wxPyDropSource,
32476 _swigt__p_unsigned_long,
32477 _swigt__p_wxKillError,
32478 _swigt__p_wxWindow,
32479 _swigt__p_wxString,
32480 _swigt__p_wxPyProcess,
32481 _swigt__p_wxBitmap,
32482 _swigt__p_wxConfig,
32483 _swigt__unsigned_int,
32484 _swigt__p_unsigned_int,
32485 _swigt__p_unsigned_char,
32486 _swigt__p_wxChar,
32487 _swigt__p_wxBusyInfo,
32488 _swigt__p_wxPyDropTarget,
32489 _swigt__p_wxPyTextDropTarget,
32490 _swigt__p_wxPyFileDropTarget,
32491 _swigt__p_wxProcessEvent,
32492 _swigt__p_wxPyLog,
32493 _swigt__p_wxLogNull,
32494 _swigt__p_wxColour,
32495 _swigt__p_wxPyTimer,
32496 _swigt__p_wxConfigPathChanger,
32497 _swigt__p_wxDateSpan,
32498 0
32499 };
32500
32501
32502 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32503
32504 static swig_const_info swig_const_table[] = {
32505 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32506 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32507 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32508 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32509 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32510 {0, 0, 0, 0.0, 0, 0}};
32511
32512 #ifdef __cplusplus
32513 }
32514 #endif
32515
32516
32517 #ifdef __cplusplus
32518 extern "C" {
32519 #endif
32520
32521 /* Python-specific SWIG API */
32522 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32523 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32524 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32525
32526 /* -----------------------------------------------------------------------------
32527 * global variable support code.
32528 * ----------------------------------------------------------------------------- */
32529
32530 typedef struct swig_globalvar {
32531 char *name; /* Name of global variable */
32532 PyObject *(*get_attr)(); /* Return the current value */
32533 int (*set_attr)(PyObject *); /* Set the value */
32534 struct swig_globalvar *next;
32535 } swig_globalvar;
32536
32537 typedef struct swig_varlinkobject {
32538 PyObject_HEAD
32539 swig_globalvar *vars;
32540 } swig_varlinkobject;
32541
32542 static PyObject *
32543 swig_varlink_repr(swig_varlinkobject *v) {
32544 v = v;
32545 return PyString_FromString("<Swig global variables>");
32546 }
32547
32548 static int
32549 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32550 swig_globalvar *var;
32551 flags = flags;
32552 fprintf(fp,"Swig global variables { ");
32553 for (var = v->vars; var; var=var->next) {
32554 fprintf(fp,"%s", var->name);
32555 if (var->next) fprintf(fp,", ");
32556 }
32557 fprintf(fp," }\n");
32558 return 0;
32559 }
32560
32561 static PyObject *
32562 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32563 swig_globalvar *var = v->vars;
32564 while (var) {
32565 if (strcmp(var->name,n) == 0) {
32566 return (*var->get_attr)();
32567 }
32568 var = var->next;
32569 }
32570 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32571 return NULL;
32572 }
32573
32574 static int
32575 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32576 swig_globalvar *var = v->vars;
32577 while (var) {
32578 if (strcmp(var->name,n) == 0) {
32579 return (*var->set_attr)(p);
32580 }
32581 var = var->next;
32582 }
32583 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32584 return 1;
32585 }
32586
32587 static PyTypeObject varlinktype = {
32588 PyObject_HEAD_INIT(0)
32589 0, /* Number of items in variable part (ob_size) */
32590 (char *)"swigvarlink", /* Type name (tp_name) */
32591 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32592 0, /* Itemsize (tp_itemsize) */
32593 0, /* Deallocator (tp_dealloc) */
32594 (printfunc) swig_varlink_print, /* Print (tp_print) */
32595 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32596 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32597 0, /* tp_compare */
32598 (reprfunc) swig_varlink_repr, /* tp_repr */
32599 0, /* tp_as_number */
32600 0, /* tp_as_sequence */
32601 0, /* tp_as_mapping */
32602 0, /* tp_hash */
32603 0, /* tp_call */
32604 0, /* tp_str */
32605 0, /* tp_getattro */
32606 0, /* tp_setattro */
32607 0, /* tp_as_buffer */
32608 0, /* tp_flags */
32609 0, /* tp_doc */
32610 #if PY_VERSION_HEX >= 0x02000000
32611 0, /* tp_traverse */
32612 0, /* tp_clear */
32613 #endif
32614 #if PY_VERSION_HEX >= 0x02010000
32615 0, /* tp_richcompare */
32616 0, /* tp_weaklistoffset */
32617 #endif
32618 #if PY_VERSION_HEX >= 0x02020000
32619 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32620 #endif
32621 #if PY_VERSION_HEX >= 0x02030000
32622 0, /* tp_del */
32623 #endif
32624 #ifdef COUNT_ALLOCS
32625 0,0,0,0 /* tp_alloc -> tp_next */
32626 #endif
32627 };
32628
32629 /* Create a variable linking object for use later */
32630 static PyObject *
32631 SWIG_Python_newvarlink(void) {
32632 swig_varlinkobject *result = 0;
32633 result = PyMem_NEW(swig_varlinkobject,1);
32634 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32635 result->ob_type = &varlinktype;
32636 result->vars = 0;
32637 result->ob_refcnt = 0;
32638 Py_XINCREF((PyObject *) result);
32639 return ((PyObject*) result);
32640 }
32641
32642 static void
32643 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32644 swig_varlinkobject *v;
32645 swig_globalvar *gv;
32646 v= (swig_varlinkobject *) p;
32647 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32648 gv->name = (char *) malloc(strlen(name)+1);
32649 strcpy(gv->name,name);
32650 gv->get_attr = get_attr;
32651 gv->set_attr = set_attr;
32652 gv->next = v->vars;
32653 v->vars = gv;
32654 }
32655
32656 /* -----------------------------------------------------------------------------
32657 * constants/methods manipulation
32658 * ----------------------------------------------------------------------------- */
32659
32660 /* Install Constants */
32661 static void
32662 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32663 PyObject *obj = 0;
32664 size_t i;
32665 for (i = 0; constants[i].type; i++) {
32666 switch(constants[i].type) {
32667 case SWIG_PY_INT:
32668 obj = PyInt_FromLong(constants[i].lvalue);
32669 break;
32670 case SWIG_PY_FLOAT:
32671 obj = PyFloat_FromDouble(constants[i].dvalue);
32672 break;
32673 case SWIG_PY_STRING:
32674 if (constants[i].pvalue) {
32675 obj = PyString_FromString((char *) constants[i].pvalue);
32676 } else {
32677 Py_INCREF(Py_None);
32678 obj = Py_None;
32679 }
32680 break;
32681 case SWIG_PY_POINTER:
32682 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32683 break;
32684 case SWIG_PY_BINARY:
32685 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32686 break;
32687 default:
32688 obj = 0;
32689 break;
32690 }
32691 if (obj) {
32692 PyDict_SetItemString(d,constants[i].name,obj);
32693 Py_DECREF(obj);
32694 }
32695 }
32696 }
32697
32698 /* -----------------------------------------------------------------------------*/
32699 /* Fix SwigMethods to carry the callback ptrs when needed */
32700 /* -----------------------------------------------------------------------------*/
32701
32702 static void
32703 SWIG_Python_FixMethods(PyMethodDef *methods,
32704 swig_const_info *const_table,
32705 swig_type_info **types,
32706 swig_type_info **types_initial) {
32707 size_t i;
32708 for (i = 0; methods[i].ml_name; ++i) {
32709 char *c = methods[i].ml_doc;
32710 if (c && (c = strstr(c, "swig_ptr: "))) {
32711 int j;
32712 swig_const_info *ci = 0;
32713 char *name = c + 10;
32714 for (j = 0; const_table[j].type; j++) {
32715 if (strncmp(const_table[j].name, name,
32716 strlen(const_table[j].name)) == 0) {
32717 ci = &(const_table[j]);
32718 break;
32719 }
32720 }
32721 if (ci) {
32722 size_t shift = (ci->ptype) - types;
32723 swig_type_info *ty = types_initial[shift];
32724 size_t ldoc = (c - methods[i].ml_doc);
32725 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32726 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32727 char *buff = ndoc;
32728 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32729 strncpy(buff, methods[i].ml_doc, ldoc);
32730 buff += ldoc;
32731 strncpy(buff, "swig_ptr: ", 10);
32732 buff += 10;
32733 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32734 methods[i].ml_doc = ndoc;
32735 }
32736 }
32737 }
32738 }
32739
32740 /* -----------------------------------------------------------------------------*
32741 * Initialize type list
32742 * -----------------------------------------------------------------------------*/
32743
32744 #if PY_MAJOR_VERSION < 2
32745 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32746 is copied out of Python/modsupport.c in python version 2.3.4 */
32747 static int
32748 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32749 {
32750 PyObject *dict;
32751 if (!PyModule_Check(m)) {
32752 PyErr_SetString(PyExc_TypeError,
32753 "PyModule_AddObject() needs module as first arg");
32754 return -1;
32755 }
32756 if (!o) {
32757 PyErr_SetString(PyExc_TypeError,
32758 "PyModule_AddObject() needs non-NULL value");
32759 return -1;
32760 }
32761
32762 dict = PyModule_GetDict(m);
32763 if (dict == NULL) {
32764 /* Internal error -- modules must have a dict! */
32765 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32766 PyModule_GetName(m));
32767 return -1;
32768 }
32769 if (PyDict_SetItemString(dict, name, o))
32770 return -1;
32771 Py_DECREF(o);
32772 return 0;
32773 }
32774 #endif
32775
32776 static swig_type_info **
32777 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32778 static PyMethodDef swig_empty_runtime_method_table[] = {
32779 {
32780 NULL, NULL, 0, NULL
32781 }
32782 };/* Sentinel */
32783
32784 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32785 swig_empty_runtime_method_table);
32786 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32787 if (pointer && module) {
32788 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32789 }
32790 return type_list_handle;
32791 }
32792
32793 static swig_type_info **
32794 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32795 swig_type_info **type_pointer;
32796
32797 /* first check if module already created */
32798 type_pointer = SWIG_Python_GetTypeListHandle();
32799 if (type_pointer) {
32800 return type_pointer;
32801 } else {
32802 /* create a new module and variable */
32803 return SWIG_Python_SetTypeListHandle(type_list_handle);
32804 }
32805 }
32806
32807 #ifdef __cplusplus
32808 }
32809 #endif
32810
32811 /* -----------------------------------------------------------------------------*
32812 * Partial Init method
32813 * -----------------------------------------------------------------------------*/
32814
32815 #ifdef SWIG_LINK_RUNTIME
32816 #ifdef __cplusplus
32817 extern "C"
32818 #endif
32819 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32820 #endif
32821
32822 #ifdef __cplusplus
32823 extern "C"
32824 #endif
32825 SWIGEXPORT(void) SWIG_init(void) {
32826 static PyObject *SWIG_globals = 0;
32827 static int typeinit = 0;
32828 PyObject *m, *d;
32829 int i;
32830 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32831
32832 /* Fix SwigMethods to carry the callback ptrs when needed */
32833 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32834
32835 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32836 d = PyModule_GetDict(m);
32837
32838 if (!typeinit) {
32839 #ifdef SWIG_LINK_RUNTIME
32840 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32841 #else
32842 # ifndef SWIG_STATIC_RUNTIME
32843 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32844 # endif
32845 #endif
32846 for (i = 0; swig_types_initial[i]; i++) {
32847 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32848 }
32849 typeinit = 1;
32850 }
32851 SWIG_InstallConstants(d,swig_const_table);
32852
32853 {
32854 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32855 }
32856 {
32857 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32858 }
32859 {
32860 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32861 }
32862 {
32863 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32864 }
32865 {
32866 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32867 }
32868 {
32869 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32870 }
32871 {
32872 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32873 }
32874 {
32875 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32876 }
32877 {
32878 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32879 }
32880 {
32881 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32882 }
32883 {
32884 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32885 }
32886 {
32887 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32888 }
32889 {
32890 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32891 }
32892 {
32893 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32894 }
32895 {
32896 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32897 }
32898 {
32899 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32900 }
32901 {
32902 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32903 }
32904 {
32905 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32906 }
32907 {
32908 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32909 }
32910 {
32911 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32912 }
32913 {
32914 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32915 }
32916 {
32917 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32918 }
32919 {
32920 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32921 }
32922 {
32923 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32924 }
32925 {
32926 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32927 }
32928 {
32929 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32930 }
32931 {
32932 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32933 }
32934 {
32935 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32936 }
32937 {
32938 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32939 }
32940 {
32941 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32942 }
32943 {
32944 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32945 }
32946 {
32947 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32948 }
32949 {
32950 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32951 }
32952 {
32953 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32954 }
32955 {
32956 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32957 }
32958 {
32959 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32960 }
32961 {
32962 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32963 }
32964 {
32965 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32966 }
32967 {
32968 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32969 }
32970 {
32971 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32972 }
32973 {
32974 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32975 }
32976 {
32977 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32978 }
32979 {
32980 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32981 }
32982 {
32983 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32984 }
32985 {
32986 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32987 }
32988 {
32989 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32990 }
32991 {
32992 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32993 }
32994 {
32995 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32996 }
32997 {
32998 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32999 }
33000 {
33001 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33002 }
33003 {
33004 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33005 }
33006 {
33007 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33008 }
33009 {
33010 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33011 }
33012 {
33013 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33014 }
33015 {
33016 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33017 }
33018 {
33019 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33020 }
33021 {
33022 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33023 }
33024 {
33025 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33026 }
33027 {
33028 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33029 }
33030 {
33031 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33032 }
33033 {
33034 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33035 }
33036 {
33037 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33038 }
33039 {
33040 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33041 }
33042 {
33043 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33044 }
33045 {
33046 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33047 }
33048 {
33049 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33050 }
33051 {
33052 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33053 }
33054 {
33055 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33056 }
33057 {
33058 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33059 }
33060 {
33061 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33062 }
33063 {
33064 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33065 }
33066 {
33067 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33068 }
33069 {
33070 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33071 }
33072 {
33073 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33074 }
33075 {
33076 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33077 }
33078 {
33079 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33080 }
33081 {
33082 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33083 }
33084 {
33085 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33086 }
33087 {
33088 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33089 }
33090 {
33091 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33092 }
33093 {
33094 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33095 }
33096 {
33097 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33098 }
33099 {
33100 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33101 }
33102 {
33103 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33104 }
33105 {
33106 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33107 }
33108 {
33109 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33110 }
33111 {
33112 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33113 }
33114 {
33115 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33116 }
33117 {
33118 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33119 }
33120 {
33121 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33122 }
33123 {
33124 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33125 }
33126 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33127 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33128 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33129 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33130 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33131 {
33132 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33133 }
33134 {
33135 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33136 }
33137 {
33138 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33139 }
33140 {
33141 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33142 }
33143 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33144
33145 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33146
33147 {
33148 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33149 }
33150 {
33151 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33152 }
33153 {
33154 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33155 }
33156 {
33157 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33158 }
33159 {
33160 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33161 }
33162 {
33163 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33164 }
33165 {
33166 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33167 }
33168 {
33169 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33170 }
33171 {
33172 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33173 }
33174 {
33175 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33176 }
33177 {
33178 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33179 }
33180 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33181 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33182 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33183 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33184 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33185 {
33186 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33277 }
33278 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33279 {
33280 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33284 }
33285 {
33286 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33287 }
33288 {
33289 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33290 }
33291 {
33292 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33293 }
33294
33295 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33296
33297 {
33298 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33317 }
33318 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33319 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33320 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33321 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33322 {
33323 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33345 }
33346 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33347 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33348 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33349 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33350 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33351 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33352 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33353 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33354 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33355 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33356 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33357 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33358 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33359 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33360 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33361 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33362 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33363 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33364 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33365 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33366 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33367 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33368 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33369 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33370 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33371 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33372 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33373 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33374 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33375 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33376 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33377 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33378 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33379 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33380 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33381 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33382 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33383 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33384 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33385 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33386 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33387 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33388 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33389 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33390 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33391
33392 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33393
33394 {
33395 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33420 }
33421 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33422 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33423 {
33424 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33524 }
33525 {
33526 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33527 }
33528 {
33529 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33530 }
33531 {
33532 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33533 }
33534 {
33535 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33536 }
33537 {
33538 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33539 }
33540 {
33541 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33542 }
33543 {
33544 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33545 }
33546 {
33547 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33743 }
33744 {
33745 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33746 }
33747 {
33748 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33749 }
33750 {
33751 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33752 }
33753 {
33754 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33755 }
33756 {
33757 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33758 }
33759 {
33760 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33761 }
33762 {
33763 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33764 }
33765 {
33766 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33767 }
33768 {
33769 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33770 }
33771 {
33772 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33773 }
33774 {
33775 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33776 }
33777 {
33778 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33779 }
33780 {
33781 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33782 }
33783 {
33784 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33785 }
33786 {
33787 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33788 }
33789 {
33790 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33791 }
33792 {
33793 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33887 }
33888 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33889 {
33890 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33948 }
33949 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33950 {
33951 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33985 }
33986
33987 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33988 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33989 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33990 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33991
33992 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33993 }
33994
wxWidgets (Impactor)