]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixed bug in Set() on DST days (patch 1097811)
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxClipboardLocker swig_types[21]
1363 #define SWIGTYPE_p_wxIcon swig_types[22]
1364 #define SWIGTYPE_p_wxLogStderr swig_types[23]
1365 #define SWIGTYPE_p_wxLogTextCtrl swig_types[24]
1366 #define SWIGTYPE_p_wxTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxBusyCursor swig_types[26]
1368 #define SWIGTYPE_p_wxBitmapDataObject swig_types[27]
1369 #define SWIGTYPE_p_wxTextDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxPyTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxFileDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxURLDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxMetafileDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxSound swig_types[36]
1378 #define SWIGTYPE_p_wxTimerRunner swig_types[37]
1379 #define SWIGTYPE_p_wxLogWindow swig_types[38]
1380 #define SWIGTYPE_p_wxTimeSpan swig_types[39]
1381 #define SWIGTYPE_p_wxArrayString swig_types[40]
1382 #define SWIGTYPE_p_wxWindowDisabler swig_types[41]
1383 #define SWIGTYPE_p_form_ops_t swig_types[42]
1384 #define SWIGTYPE_p_wxToolTip swig_types[43]
1385 #define SWIGTYPE_p_wxDataObjectComposite swig_types[44]
1386 #define SWIGTYPE_p_wxFileConfig swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxVideoMode swig_types[47]
1389 #define SWIGTYPE_p_wxDataObjectSimple swig_types[48]
1390 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
1392 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
1393 #define SWIGTYPE_p_wxRect swig_types[52]
1394 #define SWIGTYPE_p_char swig_types[53]
1395 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[54]
1396 #define SWIGTYPE_p_wxStandardPaths swig_types[55]
1397 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1398 #define SWIGTYPE_p_wxFrame swig_types[57]
1399 #define SWIGTYPE_p_wxTimer swig_types[58]
1400 #define SWIGTYPE_p_wxPaperSize swig_types[59]
1401 #define SWIGTYPE_p_wxMimeTypesManager swig_types[60]
1402 #define SWIGTYPE_p_wxPyArtProvider swig_types[61]
1403 #define SWIGTYPE_p_wxPyTipProvider swig_types[62]
1404 #define SWIGTYPE_p_wxTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxJoystick swig_types[64]
1406 #define SWIGTYPE_p_wxSystemOptions swig_types[65]
1407 #define SWIGTYPE_p_wxPoint swig_types[66]
1408 #define SWIGTYPE_p_wxJoystickEvent swig_types[67]
1409 #define SWIGTYPE_p_wxCursor swig_types[68]
1410 #define SWIGTYPE_p_wxObject swig_types[69]
1411 #define SWIGTYPE_p_wxOutputStream swig_types[70]
1412 #define SWIGTYPE_p_wxDateTime swig_types[71]
1413 #define SWIGTYPE_p_wxPyDropSource swig_types[72]
1414 #define SWIGTYPE_p_unsigned_long swig_types[73]
1415 #define SWIGTYPE_p_wxKillError swig_types[74]
1416 #define SWIGTYPE_p_wxWindow swig_types[75]
1417 #define SWIGTYPE_p_wxString swig_types[76]
1418 #define SWIGTYPE_p_wxPyProcess swig_types[77]
1419 #define SWIGTYPE_p_wxBitmap swig_types[78]
1420 #define SWIGTYPE_p_wxConfig swig_types[79]
1421 #define SWIGTYPE_unsigned_int swig_types[80]
1422 #define SWIGTYPE_p_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_char swig_types[82]
1424 #define SWIGTYPE_p_wxChar swig_types[83]
1425 #define SWIGTYPE_p_wxBusyInfo swig_types[84]
1426 #define SWIGTYPE_p_wxPyDropTarget swig_types[85]
1427 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxProcessEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPyLog swig_types[89]
1431 #define SWIGTYPE_p_wxLogNull swig_types[90]
1432 #define SWIGTYPE_p_wxColour swig_types[91]
1433 #define SWIGTYPE_p_wxPyTimer swig_types[92]
1434 #define SWIGTYPE_p_wxConfigPathChanger swig_types[93]
1435 #define SWIGTYPE_p_wxDateSpan swig_types[94]
1436 static swig_type_info *swig_types[96];
1437
1438 /* -------- TYPES TABLE (END) -------- */
1439
1440
1441 /*-----------------------------------------------
1442 @(target):= _misc_.so
1443 ------------------------------------------------*/
1444 #define SWIG_init init_misc_
1445
1446 #define SWIG_name "_misc_"
1447
1448 #include "wx/wxPython/wxPython.h"
1449 #include "wx/wxPython/pyclasses.h"
1450 #include "wx/wxPython/pyistream.h"
1451
1452 static const wxString wxPyEmptyString(wxEmptyString);
1453
1454
1455
1456 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1457 #define SWIG_From_int PyInt_FromLong
1458 /*@@*/
1459
1460
1461 #include <limits.h>
1462
1463
1464 SWIGINTERN int
1465 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1466 const char *errmsg)
1467 {
1468 if (value < min_value) {
1469 if (errmsg) {
1470 PyErr_Format(PyExc_OverflowError,
1471 "value %ld is less than '%s' minimum %ld",
1472 value, errmsg, min_value);
1473 }
1474 return 0;
1475 } else if (value > max_value) {
1476 if (errmsg) {
1477 PyErr_Format(PyExc_OverflowError,
1478 "value %ld is greater than '%s' maximum %ld",
1479 value, errmsg, max_value);
1480 }
1481 return 0;
1482 }
1483 return 1;
1484 }
1485
1486
1487 SWIGINTERN int
1488 SWIG_AsVal_long(PyObject* obj, long* val)
1489 {
1490 if (PyNumber_Check(obj)) {
1491 if (val) *val = PyInt_AsLong(obj);
1492 return 1;
1493 }
1494 else {
1495 SWIG_type_error("number", obj);
1496 }
1497 return 0;
1498 }
1499
1500
1501 #if INT_MAX != LONG_MAX
1502 SWIGINTERN int
1503 SWIG_AsVal_int(PyObject *obj, int *val)
1504 {
1505 const char* errmsg = val ? "int" : (char*)0;
1506 long v;
1507 if (SWIG_AsVal_long(obj, &v)) {
1508 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1509 if (val) *val = (int)(v);
1510 return 1;
1511 } else {
1512 return 0;
1513 }
1514 } else {
1515 PyErr_Clear();
1516 }
1517 if (val) {
1518 SWIG_type_error(errmsg, obj);
1519 }
1520 return 0;
1521 }
1522 #else
1523 SWIGINTERNSHORT int
1524 SWIG_AsVal_int(PyObject *obj, int *val)
1525 {
1526 return SWIG_AsVal_long(obj,(long*)val);
1527 }
1528 #endif
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_As_int(PyObject* obj)
1533 {
1534 int v;
1535 if (!SWIG_AsVal_int(obj, &v)) {
1536 /*
1537 this is needed to make valgrind/purify happier.
1538 */
1539 memset((void*)&v, 0, sizeof(int));
1540 }
1541 return v;
1542 }
1543
1544
1545 SWIGINTERNSHORT int
1546 SWIG_Check_int(PyObject* obj)
1547 {
1548 return SWIG_AsVal_int(obj, (int*)0);
1549 }
1550
1551 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1552
1553 #include <wx/stockitem.h>
1554
1555 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1556 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1557 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1558
1559 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1560 #define SWIG_From_long PyInt_FromLong
1561 /*@@*/
1562
1563
1564 SWIGINTERNSHORT long
1565 SWIG_As_long(PyObject* obj)
1566 {
1567 long v;
1568 if (!SWIG_AsVal_long(obj, &v)) {
1569 /*
1570 this is needed to make valgrind/purify happier.
1571 */
1572 memset((void*)&v, 0, sizeof(long));
1573 }
1574 return v;
1575 }
1576
1577
1578 SWIGINTERNSHORT int
1579 SWIG_Check_long(PyObject* obj)
1580 {
1581 return SWIG_AsVal_long(obj, (long*)0);
1582 }
1583
1584
1585 SWIGINTERN int
1586 SWIG_AsVal_bool(PyObject *obj, bool *val)
1587 {
1588 if (obj == Py_True) {
1589 if (val) *val = true;
1590 return 1;
1591 }
1592 if (obj == Py_False) {
1593 if (val) *val = false;
1594 return 1;
1595 }
1596 int res = 0;
1597 if (SWIG_AsVal_int(obj, &res)) {
1598 if (val) *val = res ? true : false;
1599 return 1;
1600 } else {
1601 PyErr_Clear();
1602 }
1603 if (val) {
1604 SWIG_type_error("bool", obj);
1605 }
1606 return 0;
1607 }
1608
1609
1610 SWIGINTERNSHORT bool
1611 SWIG_As_bool(PyObject* obj)
1612 {
1613 bool v;
1614 if (!SWIG_AsVal_bool(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(bool));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_bool(PyObject* obj)
1626 {
1627 return SWIG_AsVal_bool(obj, (bool*)0);
1628 }
1629
1630
1631 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1632 PyObject* o2;
1633 PyObject* o3;
1634
1635 if (!target) {
1636 target = o;
1637 } else if (target == Py_None) {
1638 Py_DECREF(Py_None);
1639 target = o;
1640 } else {
1641 if (!PyTuple_Check(target)) {
1642 o2 = target;
1643 target = PyTuple_New(1);
1644 PyTuple_SetItem(target, 0, o2);
1645 }
1646 o3 = PyTuple_New(1);
1647 PyTuple_SetItem(o3, 0, o);
1648
1649 o2 = target;
1650 target = PySequence_Concat(o2, o3);
1651 Py_DECREF(o2);
1652 Py_DECREF(o3);
1653 }
1654 return target;
1655 }
1656
1657
1658
1659 long wxGetFreeMemory()
1660 { wxPyRaiseNotImplemented(); return 0; }
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void wxWakeUpMainThread() {}
1707
1708
1709 bool wxThread_IsMain() {
1710 #ifdef WXP_WITH_THREAD
1711 return wxThread::IsMain();
1712 #else
1713 return true;
1714 #endif
1715 }
1716
1717
1718 int wxCaret_GetBlinkTime() {
1719 return wxCaret::GetBlinkTime();
1720 }
1721
1722 void wxCaret_SetBlinkTime(int milliseconds) {
1723 wxCaret::SetBlinkTime(milliseconds);
1724 }
1725
1726
1727 #include <wx/snglinst.h>
1728
1729
1730 #include <wx/tipdlg.h>
1731
1732
1733 class wxPyTipProvider : public wxTipProvider {
1734 public:
1735 wxPyTipProvider(size_t currentTip)
1736 : wxTipProvider(currentTip) {}
1737
1738 DEC_PYCALLBACK_STRING__pure(GetTip);
1739 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1740 PYPRIVATE;
1741 };
1742
1743 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1744 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1745
1746
1747 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1748
1749 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1750
1751 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1752 : wxTimer(owner, id)
1753 {
1754 if (owner == NULL) SetOwner(this);
1755 }
1756
1757
1758 void wxPyTimer::Notify() {
1759 bool found;
1760 bool blocked = wxPyBeginBlockThreads();
1761 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1762 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1763 wxPyEndBlockThreads(blocked);
1764 if (! found)
1765 wxTimer::Notify();
1766 }
1767 void wxPyTimer::base_Notify() {
1768 wxTimer::Notify();
1769 }
1770
1771
1772
1773 SWIGINTERN PyObject *
1774 SWIG_FromCharPtr(const char* cptr)
1775 {
1776 if (cptr) {
1777 size_t size = strlen(cptr);
1778 if (size > INT_MAX) {
1779 return SWIG_NewPointerObj((char*)(cptr),
1780 SWIG_TypeQuery("char *"), 0);
1781 } else {
1782 if (size != 0) {
1783 return PyString_FromStringAndSize(cptr, size);
1784 } else {
1785 return PyString_FromString(cptr);
1786 }
1787 }
1788 }
1789 Py_INCREF(Py_None);
1790 return Py_None;
1791 }
1792
1793
1794 SWIGINTERNSHORT int
1795 SWIG_CheckUnsignedLongInRange(unsigned long value,
1796 unsigned long max_value,
1797 const char *errmsg)
1798 {
1799 if (value > max_value) {
1800 if (errmsg) {
1801 PyErr_Format(PyExc_OverflowError,
1802 "value %lu is greater than '%s' minimum %lu",
1803 value, errmsg, max_value);
1804 }
1805 return 0;
1806 }
1807 return 1;
1808 }
1809
1810
1811 #if UINT_MAX != ULONG_MAX
1812 SWIGINTERN int
1813 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1814 {
1815 const char* errmsg = val ? "unsigned int" : (char*)0;
1816 unsigned long v;
1817 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1818 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1819 if (val) *val = (unsigned int)(v);
1820 return 1;
1821 }
1822 } else {
1823 PyErr_Clear();
1824 }
1825 if (val) {
1826 SWIG_type_error(errmsg, obj);
1827 }
1828 return 0;
1829 }
1830 #else
1831 SWIGINTERNSHORT unsigned int
1832 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1833 {
1834 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1835 }
1836 #endif
1837
1838
1839 SWIGINTERNSHORT unsigned int
1840 SWIG_As_unsigned_SS_int(PyObject* obj)
1841 {
1842 unsigned int v;
1843 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1844 /*
1845 this is needed to make valgrind/purify happier.
1846 */
1847 memset((void*)&v, 0, sizeof(unsigned int));
1848 }
1849 return v;
1850 }
1851
1852
1853 SWIGINTERNSHORT int
1854 SWIG_Check_unsigned_SS_int(PyObject* obj)
1855 {
1856 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1857 }
1858
1859 static wxString Log_TimeStamp(){
1860 wxString msg;
1861 wxLog::TimeStamp(&msg);
1862 return msg;
1863 }
1864 static void wxLog_Destroy(wxLog *self){ delete self; }
1865 // Make somce wrappers that double any % signs so they are 'escaped'
1866 void wxPyLogFatalError(const wxString& msg)
1867 {
1868 wxString m(msg);
1869 m.Replace(wxT("%"), wxT("%%"));
1870 wxLogFatalError(m);
1871 }
1872
1873 void wxPyLogError(const wxString& msg)
1874 {
1875 wxString m(msg);
1876 m.Replace(wxT("%"), wxT("%%"));
1877 wxLogError(m);
1878 }
1879
1880 void wxPyLogWarning(const wxString& msg)
1881 {
1882 wxString m(msg);
1883 m.Replace(wxT("%"), wxT("%%"));
1884 wxLogWarning(m);
1885 }
1886
1887 void wxPyLogMessage(const wxString& msg)
1888 {
1889 wxString m(msg);
1890 m.Replace(wxT("%"), wxT("%%"));
1891 wxLogMessage(m);
1892 }
1893
1894 void wxPyLogInfo(const wxString& msg)
1895 {
1896 wxString m(msg);
1897 m.Replace(wxT("%"), wxT("%%"));
1898 wxLogInfo(m);
1899 }
1900
1901 void wxPyLogDebug(const wxString& msg)
1902 {
1903 wxString m(msg);
1904 m.Replace(wxT("%"), wxT("%%"));
1905 wxLogDebug(m);
1906 }
1907
1908 void wxPyLogVerbose(const wxString& msg)
1909 {
1910 wxString m(msg);
1911 m.Replace(wxT("%"), wxT("%%"));
1912 wxLogVerbose(m);
1913 }
1914
1915 void wxPyLogStatus(const wxString& msg)
1916 {
1917 wxString m(msg);
1918 m.Replace(wxT("%"), wxT("%%"));
1919 wxLogStatus(m);
1920 }
1921
1922 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1923 {
1924 wxString m(msg);
1925 m.Replace(wxT("%"), wxT("%%"));
1926 wxLogStatus(pFrame, m);
1927 }
1928
1929 void wxPyLogSysError(const wxString& msg)
1930 {
1931 wxString m(msg);
1932 m.Replace(wxT("%"), wxT("%%"));
1933 wxLogSysError(m);
1934 }
1935
1936 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1937 {
1938 wxString m(msg);
1939 m.Replace(wxT("%"), wxT("%%"));
1940 wxLogGeneric(level, m);
1941 }
1942
1943 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1944 {
1945 wxString m(msg);
1946 m.Replace(wxT("%"), wxT("%%"));
1947 wxLogTrace(mask, m);
1948 }
1949
1950 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogTrace(mask, m);
1955 }
1956
1957
1958
1959 // A wxLog class that can be derived from in wxPython
1960 class wxPyLog : public wxLog {
1961 public:
1962 wxPyLog() : wxLog() {}
1963
1964 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1965 bool found;
1966 bool blocked = wxPyBeginBlockThreads();
1967 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1968 PyObject* s = wx2PyString(szString);
1969 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1970 Py_DECREF(s);
1971 }
1972 wxPyEndBlockThreads(blocked);
1973 if (! found)
1974 wxLog::DoLog(level, szString, t);
1975 }
1976
1977 virtual void DoLogString(const wxChar *szString, time_t t) {
1978 bool found;
1979 bool blocked = wxPyBeginBlockThreads();
1980 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1981 PyObject* s = wx2PyString(szString);
1982 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1983 Py_DECREF(s);
1984 }
1985 wxPyEndBlockThreads(blocked);
1986 if (! found)
1987 wxLog::DoLogString(szString, t);
1988 }
1989
1990 PYPRIVATE;
1991 };
1992
1993
1994
1995
1996 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1997
1998
1999 #include <wx/joystick.h>
2000
2001
2002 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2003 // A C++ stub class for wxJoystick for platforms that don't have it.
2004 class wxJoystick : public wxObject {
2005 public:
2006 wxJoystick(int joystick = wxJOYSTICK1) {
2007 bool blocked = wxPyBeginBlockThreads();
2008 PyErr_SetString(PyExc_NotImplementedError,
2009 "wxJoystick is not available on this platform.");
2010 wxPyEndBlockThreads(blocked);
2011 }
2012 wxPoint GetPosition() { return wxPoint(-1,-1); }
2013 int GetZPosition() { return -1; }
2014 int GetButtonState() { return -1; }
2015 int GetPOVPosition() { return -1; }
2016 int GetPOVCTSPosition() { return -1; }
2017 int GetRudderPosition() { return -1; }
2018 int GetUPosition() { return -1; }
2019 int GetVPosition() { return -1; }
2020 int GetMovementThreshold() { return -1; }
2021 void SetMovementThreshold(int threshold) {}
2022
2023 bool IsOk(void) { return false; }
2024 int GetNumberJoysticks() { return -1; }
2025 int GetManufacturerId() { return -1; }
2026 int GetProductId() { return -1; }
2027 wxString GetProductName() { return wxEmptyString; }
2028 int GetXMin() { return -1; }
2029 int GetYMin() { return -1; }
2030 int GetZMin() { return -1; }
2031 int GetXMax() { return -1; }
2032 int GetYMax() { return -1; }
2033 int GetZMax() { return -1; }
2034 int GetNumberButtons() { return -1; }
2035 int GetNumberAxes() { return -1; }
2036 int GetMaxButtons() { return -1; }
2037 int GetMaxAxes() { return -1; }
2038 int GetPollingMin() { return -1; }
2039 int GetPollingMax() { return -1; }
2040 int GetRudderMin() { return -1; }
2041 int GetRudderMax() { return -1; }
2042 int GetUMin() { return -1; }
2043 int GetUMax() { return -1; }
2044 int GetVMin() { return -1; }
2045 int GetVMax() { return -1; }
2046
2047 bool HasRudder() { return false; }
2048 bool HasZ() { return false; }
2049 bool HasU() { return false; }
2050 bool HasV() { return false; }
2051 bool HasPOV() { return false; }
2052 bool HasPOV4Dir() { return false; }
2053 bool HasPOVCTS() { return false; }
2054
2055 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2056 bool ReleaseCapture() { return false; }
2057 };
2058 #endif
2059
2060
2061 #include <wx/sound.h>
2062
2063
2064 #if !wxUSE_SOUND
2065 // A C++ stub class for wxWave for platforms that don't have it.
2066 class wxSound : public wxObject
2067 {
2068 public:
2069 wxSound() {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(const wxString&/*, bool*/) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081 wxSound(int, const wxByte*) {
2082 bool blocked = wxPyBeginBlockThreads();
2083 PyErr_SetString(PyExc_NotImplementedError,
2084 "wxSound is not available on this platform.");
2085 wxPyEndBlockThreads(blocked);
2086 }
2087
2088 ~wxSound() {};
2089
2090 bool Create(const wxString&/*, bool*/) { return false; }
2091 bool Create(int, const wxByte*) { return false; };
2092 bool IsOk() { return false; };
2093 bool Play(unsigned) const { return false; }
2094 static bool Play(const wxString&, unsigned) { return false; }
2095 static void Stop() {}
2096 };
2097
2098 #endif
2099
2100 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2101 if (fileName.Length() == 0)
2102 return new wxSound;
2103 else
2104 return new wxSound(fileName);
2105 }
2106 static wxSound *new_wxSound(PyObject *data){
2107 unsigned char* buffer; int size;
2108 wxSound *sound = NULL;
2109
2110 bool blocked = wxPyBeginBlockThreads();
2111 if (!PyArg_Parse(data, "t#", &buffer, &size))
2112 goto done;
2113 sound = new wxSound(size, buffer);
2114 done:
2115 wxPyEndBlockThreads(blocked);
2116 return sound;
2117 }
2118 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2119 #ifndef __WXMAC__
2120 unsigned char* buffer;
2121 int size;
2122 bool rv = false;
2123
2124 bool blocked = wxPyBeginBlockThreads();
2125 if (!PyArg_Parse(data, "t#", &buffer, &size))
2126 goto done;
2127 rv = self->Create(size, buffer);
2128 done:
2129 wxPyEndBlockThreads(blocked);
2130 return rv;
2131 #else
2132 bool blocked = wxPyBeginBlockThreads();
2133 PyErr_SetString(PyExc_NotImplementedError,
2134 "Create from data is not available on this platform.");
2135 wxPyEndBlockThreads(blocked);
2136 return false;
2137 #endif
2138 }
2139
2140 #include <wx/mimetype.h>
2141
2142 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2143 wxString str;
2144 if (self->GetMimeType(&str))
2145 return wx2PyString(str);
2146 else
2147 RETURN_NONE();
2148 }
2149 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2150 wxArrayString arr;
2151 if (self->GetMimeTypes(arr))
2152 return wxArrayString2PyList_helper(arr);
2153 else
2154 RETURN_NONE();
2155 }
2156 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2157 wxArrayString arr;
2158 if (self->GetExtensions(arr))
2159 return wxArrayString2PyList_helper(arr);
2160 else
2161 RETURN_NONE();
2162 }
2163 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2164 wxIconLocation loc;
2165 if (self->GetIcon(&loc))
2166 return new wxIcon(loc);
2167 else
2168 return NULL;
2169 }
2170 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2171 wxIconLocation loc;
2172 if (self->GetIcon(&loc)) {
2173 wxString iconFile = loc.GetFileName();
2174 int iconIndex = -1;
2175
2176
2177
2178 // Make a tuple and put the values in it
2179 bool blocked = wxPyBeginBlockThreads();
2180 PyObject* tuple = PyTuple_New(3);
2181 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2182 wxT("wxIcon"), true));
2183 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2184 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2185 wxPyEndBlockThreads(blocked);
2186 return tuple;
2187 }
2188 else
2189 RETURN_NONE();
2190 }
2191 static PyObject *wxFileType_GetDescription(wxFileType *self){
2192 wxString str;
2193 if (self->GetDescription(&str))
2194 return wx2PyString(str);
2195 else
2196 RETURN_NONE();
2197 }
2198 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2199 wxString str;
2200 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2201 return wx2PyString(str);
2202 else
2203 RETURN_NONE();
2204 }
2205 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2206 wxString str;
2207 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2208 return wx2PyString(str);
2209 else
2210 RETURN_NONE();
2211 }
2212 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2213 wxArrayString verbs;
2214 wxArrayString commands;
2215 if (self->GetAllCommands(&verbs, &commands,
2216 wxFileType::MessageParameters(filename, mimetype))) {
2217 bool blocked = wxPyBeginBlockThreads();
2218 PyObject* tuple = PyTuple_New(2);
2219 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2220 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2221 wxPyEndBlockThreads(blocked);
2222 return tuple;
2223 }
2224 else
2225 RETURN_NONE();
2226 }
2227 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2228 return wxFileType::ExpandCommand(command,
2229 wxFileType::MessageParameters(filename, mimetype));
2230 }
2231 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2232 wxArrayString arr;
2233 self->EnumAllFileTypes(arr);
2234 return wxArrayString2PyList_helper(arr);
2235 }
2236
2237 #include <wx/artprov.h>
2238
2239 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2240 static const wxString wxPyART_MENU(wxART_MENU);
2241 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2242 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2243 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2244 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2245 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2246 static const wxString wxPyART_OTHER(wxART_OTHER);
2247 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2248 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2249 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2250 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2251 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2252 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2253 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2254 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2255 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2256 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2257 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2258 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2259 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2260 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2261 static const wxString wxPyART_PRINT(wxART_PRINT);
2262 static const wxString wxPyART_HELP(wxART_HELP);
2263 static const wxString wxPyART_TIP(wxART_TIP);
2264 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2265 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2266 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2267 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2268 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2269 static const wxString wxPyART_CDROM(wxART_CDROM);
2270 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2271 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2272 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2273 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2274 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2275 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2276 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2277 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2278 static const wxString wxPyART_ERROR(wxART_ERROR);
2279 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2280 static const wxString wxPyART_WARNING(wxART_WARNING);
2281 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2282 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2283 // Python aware wxArtProvider
2284 class wxPyArtProvider : public wxArtProvider {
2285 public:
2286
2287 virtual wxBitmap CreateBitmap(const wxArtID& id,
2288 const wxArtClient& client,
2289 const wxSize& size) {
2290 wxBitmap rval = wxNullBitmap;
2291 bool blocked = wxPyBeginBlockThreads();
2292 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2293 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2294 PyObject* ro;
2295 wxBitmap* ptr;
2296 PyObject* s1, *s2;
2297 s1 = wx2PyString(id);
2298 s2 = wx2PyString(client);
2299 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2300 Py_DECREF(so);
2301 Py_DECREF(s1);
2302 Py_DECREF(s2);
2303 if (ro) {
2304 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2305 rval = *ptr;
2306 Py_DECREF(ro);
2307 }
2308 }
2309 wxPyEndBlockThreads(blocked);
2310 return rval;
2311 }
2312
2313 PYPRIVATE;
2314 };
2315
2316 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2317
2318
2319
2320 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2321 PyObject* ret = PyTuple_New(3);
2322 if (ret) {
2323 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2324 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2325 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2326 }
2327 return ret;
2328 }
2329
2330 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2331 bool cont;
2332 long index = 0;
2333 wxString value;
2334
2335 cont = self->GetFirstGroup(value, index);
2336 return __EnumerationHelper(cont, value, index);
2337 }
2338 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2339 bool cont;
2340 wxString value;
2341
2342 cont = self->GetNextGroup(value, index);
2343 return __EnumerationHelper(cont, value, index);
2344 }
2345 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2346 bool cont;
2347 long index = 0;
2348 wxString value;
2349
2350 cont = self->GetFirstEntry(value, index);
2351 return __EnumerationHelper(cont, value, index);
2352 }
2353 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2354 bool cont;
2355 wxString value;
2356
2357 cont = self->GetNextEntry(value, index);
2358 return __EnumerationHelper(cont, value, index);
2359 }
2360 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2361 long rv;
2362 self->Read(key, &rv, defaultVal);
2363 return rv;
2364 }
2365
2366 SWIGINTERN int
2367 SWIG_AsVal_double(PyObject *obj, double* val)
2368 {
2369 if (PyNumber_Check(obj)) {
2370 if (val) *val = PyFloat_AsDouble(obj);
2371 return 1;
2372 }
2373 else {
2374 SWIG_type_error("number", obj);
2375 }
2376 return 0;
2377 }
2378
2379
2380 SWIGINTERNSHORT double
2381 SWIG_As_double(PyObject* obj)
2382 {
2383 double v;
2384 if (!SWIG_AsVal_double(obj, &v)) {
2385 /*
2386 this is needed to make valgrind/purify happier.
2387 */
2388 memset((void*)&v, 0, sizeof(double));
2389 }
2390 return v;
2391 }
2392
2393
2394 SWIGINTERNSHORT int
2395 SWIG_Check_double(PyObject* obj)
2396 {
2397 return SWIG_AsVal_double(obj, (double*)0);
2398 }
2399
2400 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2401 double rv;
2402 self->Read(key, &rv, defaultVal);
2403 return rv;
2404 }
2405
2406 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2407 #define SWIG_From_double PyFloat_FromDouble
2408 /*@@*/
2409
2410 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2411 bool rv;
2412 self->Read(key, &rv, defaultVal);
2413 return rv;
2414 }
2415
2416 #include <wx/datetime.h>
2417
2418 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2419 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2420
2421 #define LOCAL_TZ wxDateTime::Local
2422
2423
2424 #if UINT_MAX < LONG_MAX
2425 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2426 #define SWIG_From_unsigned_SS_int SWIG_From_long
2427 /*@@*/
2428 #else
2429 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2430 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2431 /*@@*/
2432 #endif
2433
2434 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2435 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2436 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2437 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2438 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2439 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2440 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2441 return (*self < *other);
2442 }
2443 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2444 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2445 return (*self <= *other);
2446 }
2447 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2448 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2449 return (*self > *other);
2450 }
2451 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2452 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2453 return (*self >= *other);
2454 }
2455 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2456 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2457 return (*self == *other);
2458 }
2459 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2460 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2461 return (*self != *other);
2462 }
2463 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2464 const wxChar* rv;
2465 const wxChar* _date = date;
2466 rv = self->ParseRfc822Date(_date);
2467 if (rv == NULL) return -1;
2468 return rv - _date;
2469 }
2470 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2471 const wxChar* rv;
2472 const wxChar* _date = date;
2473 rv = self->ParseFormat(_date, format, dateDef);
2474 if (rv == NULL) return -1;
2475 return rv - _date;
2476 }
2477 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2478 const wxChar* rv;
2479 const wxChar* _datetime = datetime;
2480 rv = self->ParseDateTime(_datetime);
2481 if (rv == NULL) return -1;
2482 return rv - _datetime;
2483 }
2484 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2485 const wxChar* rv;
2486 const wxChar* _date = date;
2487 rv = self->ParseDate(_date);
2488 if (rv == NULL) return -1;
2489 return rv - _date;
2490 }
2491 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2492 const wxChar* rv;
2493 const wxChar* _time = time;
2494 rv = self->ParseTime(_time);
2495 if (rv == NULL) return -1;
2496 return rv - _time;
2497 }
2498 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2499 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2500 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2501 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2502 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2503 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2504 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2505 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2506 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2507 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2508 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2509 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2510 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2511 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2512 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2513 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2514
2515 #include <wx/dataobj.h>
2516
2517 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2518 size_t count = self->GetFormatCount(dir);
2519 wxDataFormat* formats = new wxDataFormat[count];
2520 self->GetAllFormats(formats, dir);
2521
2522 bool blocked = wxPyBeginBlockThreads();
2523 PyObject* list = PyList_New(count);
2524 for (size_t i=0; i<count; i++) {
2525 wxDataFormat* format = new wxDataFormat(formats[i]);
2526 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2527 PyList_Append(list, obj);
2528 Py_DECREF(obj);
2529 }
2530 wxPyEndBlockThreads(blocked);
2531 delete [] formats;
2532 return list;
2533 }
2534 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2535 PyObject* rval = NULL;
2536 size_t size = self->GetDataSize(format);
2537 bool blocked = wxPyBeginBlockThreads();
2538 if (size) {
2539 char* buf = new char[size];
2540 if (self->GetDataHere(format, buf))
2541 rval = PyString_FromStringAndSize(buf, size);
2542 delete [] buf;
2543 }
2544 if (! rval) {
2545 rval = Py_None;
2546 Py_INCREF(rval);
2547 }
2548 wxPyEndBlockThreads(blocked);
2549 return rval;
2550 }
2551 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2552 bool rval;
2553 bool blocked = wxPyBeginBlockThreads();
2554 if (PyString_Check(data)) {
2555 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2556 }
2557 else {
2558 // raise a TypeError if not a string
2559 PyErr_SetString(PyExc_TypeError, "String expected.");
2560 rval = false;
2561 }
2562 wxPyEndBlockThreads(blocked);
2563 return rval;
2564 }
2565 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2566 PyObject* rval = NULL;
2567 size_t size = self->GetDataSize();
2568 bool blocked = wxPyBeginBlockThreads();
2569 if (size) {
2570 char* buf = new char[size];
2571 if (self->GetDataHere(buf))
2572 rval = PyString_FromStringAndSize(buf, size);
2573 delete [] buf;
2574 }
2575 if (! rval) {
2576 rval = Py_None;
2577 Py_INCREF(rval);
2578 }
2579 wxPyEndBlockThreads(blocked);
2580 return rval;
2581 }
2582 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2583 bool rval;
2584 bool blocked = wxPyBeginBlockThreads();
2585 if (PyString_Check(data)) {
2586 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2587 }
2588 else {
2589 // raise a TypeError if not a string
2590 PyErr_SetString(PyExc_TypeError, "String expected.");
2591 rval = false;
2592 }
2593 wxPyEndBlockThreads(blocked);
2594 return rval;
2595 }
2596 // Create a new class for wxPython to use
2597 class wxPyDataObjectSimple : public wxDataObjectSimple {
2598 public:
2599 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2600 : wxDataObjectSimple(format) {}
2601
2602 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2603 bool GetDataHere(void *buf) const;
2604 bool SetData(size_t len, const void *buf) const;
2605 PYPRIVATE;
2606 };
2607
2608 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2609
2610 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2611 // We need to get the data for this object and write it to buf. I think
2612 // the best way to do this for wxPython is to have the Python method
2613 // return either a string or None and then act appropriately with the
2614 // C++ version.
2615
2616 bool rval = false;
2617 bool blocked = wxPyBeginBlockThreads();
2618 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2619 PyObject* ro;
2620 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2621 if (ro) {
2622 rval = (ro != Py_None && PyString_Check(ro));
2623 if (rval)
2624 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2625 Py_DECREF(ro);
2626 }
2627 }
2628 wxPyEndBlockThreads(blocked);
2629 return rval;
2630 }
2631
2632 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2633 // For this one we simply need to make a string from buf and len
2634 // and send it to the Python method.
2635 bool rval = false;
2636 bool blocked = wxPyBeginBlockThreads();
2637 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2638 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2639 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2640 Py_DECREF(data);
2641 }
2642 wxPyEndBlockThreads(blocked);
2643 return rval;
2644 }
2645
2646 // Create a new class for wxPython to use
2647 class wxPyTextDataObject : public wxTextDataObject {
2648 public:
2649 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2650 : wxTextDataObject(text) {}
2651
2652 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2653 DEC_PYCALLBACK_STRING__const(GetText);
2654 DEC_PYCALLBACK__STRING(SetText);
2655 PYPRIVATE;
2656 };
2657
2658 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2659 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2660 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2661
2662
2663 // Create a new class for wxPython to use
2664 class wxPyBitmapDataObject : public wxBitmapDataObject {
2665 public:
2666 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2667 : wxBitmapDataObject(bitmap) {}
2668
2669 wxBitmap GetBitmap() const;
2670 void SetBitmap(const wxBitmap& bitmap);
2671 PYPRIVATE;
2672 };
2673
2674 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2675 wxBitmap* rval = &wxNullBitmap;
2676 bool blocked = wxPyBeginBlockThreads();
2677 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2678 PyObject* ro;
2679 wxBitmap* ptr;
2680 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2681 if (ro) {
2682 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2683 rval = ptr;
2684 Py_DECREF(ro);
2685 }
2686 }
2687 wxPyEndBlockThreads(blocked);
2688 return *rval;
2689 }
2690
2691 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2692 bool blocked = wxPyBeginBlockThreads();
2693 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2694 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2695 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2696 Py_DECREF(bo);
2697 }
2698 wxPyEndBlockThreads(blocked);
2699 }
2700
2701 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2702 return new wxCustomDataObject(wxDataFormat(formatName));
2703 }
2704 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2705 bool rval;
2706 bool blocked = wxPyBeginBlockThreads();
2707 if (PyString_Check(data)) {
2708 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2709 }
2710 else {
2711 // raise a TypeError if not a string
2712 PyErr_SetString(PyExc_TypeError, "String expected.");
2713 rval = false;
2714 }
2715 wxPyEndBlockThreads(blocked);
2716 return rval;
2717 }
2718 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2719 PyObject* obj;
2720 bool blocked = wxPyBeginBlockThreads();
2721 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2722 wxPyEndBlockThreads(blocked);
2723 return obj;
2724 }
2725
2726 class wxMetafileDataObject : public wxDataObjectSimple
2727 {
2728 public:
2729 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2730 };
2731
2732
2733 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2734
2735
2736 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2737 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2738 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2739 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2740 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2741
2742
2743 class wxPyTextDropTarget : public wxTextDropTarget {
2744 public:
2745 wxPyTextDropTarget() {}
2746
2747 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2748
2749 DEC_PYCALLBACK__(OnLeave);
2750 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2751 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2752 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2753 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2754
2755 PYPRIVATE;
2756 };
2757
2758 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2759 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2760 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2761 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2762 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2763 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2764
2765
2766
2767 class wxPyFileDropTarget : public wxFileDropTarget {
2768 public:
2769 wxPyFileDropTarget() {}
2770
2771 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2772
2773 DEC_PYCALLBACK__(OnLeave);
2774 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2775 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2776 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2777 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2778
2779 PYPRIVATE;
2780 };
2781
2782 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2783 const wxArrayString& filenames) {
2784 bool rval = false;
2785 bool blocked = wxPyBeginBlockThreads();
2786 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2787 PyObject* list = wxArrayString2PyList_helper(filenames);
2788 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2789 Py_DECREF(list);
2790 }
2791 wxPyEndBlockThreads(blocked);
2792 return rval;
2793 }
2794
2795
2796
2797 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2798 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2799 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2800 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2801 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2802
2803
2804
2805
2806 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2807
2808 #include <wx/display.h>
2809
2810 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2811 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2812
2813 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2814 #if !wxUSE_DISPLAY
2815 #include <wx/dynarray.h>
2816 #include <wx/vidmode.h>
2817
2818 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2819 #include "wx/arrimpl.cpp"
2820 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2821 const wxVideoMode wxDefaultVideoMode;
2822
2823 class wxDisplay
2824 {
2825 public:
2826 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2827 ~wxDisplay() {}
2828
2829 static size_t GetCount()
2830 { wxPyRaiseNotImplemented(); return 0; }
2831
2832 static int GetFromPoint(const wxPoint& pt)
2833 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2834 static int GetFromWindow(wxWindow *window)
2835 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2836
2837 virtual bool IsOk() const { return false; }
2838 virtual wxRect GetGeometry() const { wxRect r; return r; }
2839 virtual wxString GetName() const { return wxEmptyString; }
2840 bool IsPrimary() const { return false; }
2841
2842 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2843 { wxArrayVideoModes a; return a; }
2844
2845 virtual wxVideoMode GetCurrentMode() const
2846 { return wxDefaultVideoMode; }
2847
2848 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2849 { return false; }
2850
2851 void ResetMode() {}
2852 };
2853 #endif
2854
2855 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2856 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2857 PyObject* pyList = NULL;
2858 wxArrayVideoModes arr = self->GetModes(mode);
2859 bool blocked = wxPyBeginBlockThreads();
2860 pyList = PyList_New(0);
2861 for (int i=0; i < arr.GetCount(); i++) {
2862 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2863 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2864 PyList_Append(pyList, pyObj);
2865 Py_DECREF(pyObj);
2866 }
2867 wxPyEndBlockThreads(blocked);
2868 return pyList;
2869 }
2870
2871 #include <wx/stdpaths.h>
2872
2873 static wxStandardPaths *StandardPaths_Get(){
2874 return (wxStandardPaths*) &wxStandardPaths::Get();
2875 }
2876 #ifdef __cplusplus
2877 extern "C" {
2878 #endif
2879 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2880 PyObject *resultobj;
2881 wxSystemColour arg1 ;
2882 wxColour result;
2883 PyObject * obj0 = 0 ;
2884 char *kwnames[] = {
2885 (char *) "index", NULL
2886 };
2887
2888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2889 {
2890 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2891 if (SWIG_arg_fail(1)) SWIG_fail;
2892 }
2893 {
2894 if (!wxPyCheckForApp()) SWIG_fail;
2895 PyThreadState* __tstate = wxPyBeginAllowThreads();
2896 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2897
2898 wxPyEndAllowThreads(__tstate);
2899 if (PyErr_Occurred()) SWIG_fail;
2900 }
2901 {
2902 wxColour * resultptr;
2903 resultptr = new wxColour((wxColour &)(result));
2904 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2905 }
2906 return resultobj;
2907 fail:
2908 return NULL;
2909 }
2910
2911
2912 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2913 PyObject *resultobj;
2914 wxSystemFont arg1 ;
2915 wxFont result;
2916 PyObject * obj0 = 0 ;
2917 char *kwnames[] = {
2918 (char *) "index", NULL
2919 };
2920
2921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2922 {
2923 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2924 if (SWIG_arg_fail(1)) SWIG_fail;
2925 }
2926 {
2927 if (!wxPyCheckForApp()) SWIG_fail;
2928 PyThreadState* __tstate = wxPyBeginAllowThreads();
2929 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2930
2931 wxPyEndAllowThreads(__tstate);
2932 if (PyErr_Occurred()) SWIG_fail;
2933 }
2934 {
2935 wxFont * resultptr;
2936 resultptr = new wxFont((wxFont &)(result));
2937 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2938 }
2939 return resultobj;
2940 fail:
2941 return NULL;
2942 }
2943
2944
2945 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2946 PyObject *resultobj;
2947 wxSystemMetric arg1 ;
2948 int result;
2949 PyObject * obj0 = 0 ;
2950 char *kwnames[] = {
2951 (char *) "index", NULL
2952 };
2953
2954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2955 {
2956 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2957 if (SWIG_arg_fail(1)) SWIG_fail;
2958 }
2959 {
2960 if (!wxPyCheckForApp()) SWIG_fail;
2961 PyThreadState* __tstate = wxPyBeginAllowThreads();
2962 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2963
2964 wxPyEndAllowThreads(__tstate);
2965 if (PyErr_Occurred()) SWIG_fail;
2966 }
2967 {
2968 resultobj = SWIG_From_int((int)(result));
2969 }
2970 return resultobj;
2971 fail:
2972 return NULL;
2973 }
2974
2975
2976 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2977 PyObject *resultobj;
2978 wxSystemFeature arg1 ;
2979 bool result;
2980 PyObject * obj0 = 0 ;
2981 char *kwnames[] = {
2982 (char *) "index", NULL
2983 };
2984
2985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2986 {
2987 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2988 if (SWIG_arg_fail(1)) SWIG_fail;
2989 }
2990 {
2991 if (!wxPyCheckForApp()) SWIG_fail;
2992 PyThreadState* __tstate = wxPyBeginAllowThreads();
2993 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2994
2995 wxPyEndAllowThreads(__tstate);
2996 if (PyErr_Occurred()) SWIG_fail;
2997 }
2998 {
2999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3000 }
3001 return resultobj;
3002 fail:
3003 return NULL;
3004 }
3005
3006
3007 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3008 PyObject *resultobj;
3009 wxSystemScreenType result;
3010 char *kwnames[] = {
3011 NULL
3012 };
3013
3014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3015 {
3016 if (!wxPyCheckForApp()) SWIG_fail;
3017 PyThreadState* __tstate = wxPyBeginAllowThreads();
3018 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3019
3020 wxPyEndAllowThreads(__tstate);
3021 if (PyErr_Occurred()) SWIG_fail;
3022 }
3023 resultobj = SWIG_From_int((result));
3024 return resultobj;
3025 fail:
3026 return NULL;
3027 }
3028
3029
3030 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3031 PyObject *resultobj;
3032 wxSystemScreenType arg1 ;
3033 PyObject * obj0 = 0 ;
3034 char *kwnames[] = {
3035 (char *) "screen", NULL
3036 };
3037
3038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3039 {
3040 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 }
3043 {
3044 if (!wxPyCheckForApp()) SWIG_fail;
3045 PyThreadState* __tstate = wxPyBeginAllowThreads();
3046 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3047
3048 wxPyEndAllowThreads(__tstate);
3049 if (PyErr_Occurred()) SWIG_fail;
3050 }
3051 Py_INCREF(Py_None); resultobj = Py_None;
3052 return resultobj;
3053 fail:
3054 return NULL;
3055 }
3056
3057
3058 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3059 PyObject *obj;
3060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3061 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3062 Py_INCREF(obj);
3063 return Py_BuildValue((char *)"");
3064 }
3065 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3066 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3067 return 1;
3068 }
3069
3070
3071 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3072 PyObject *pyobj;
3073
3074 {
3075 #if wxUSE_UNICODE
3076 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3077 #else
3078 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3079 #endif
3080 }
3081 return pyobj;
3082 }
3083
3084
3085 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3086 PyObject *resultobj;
3087 wxSystemOptions *result;
3088 char *kwnames[] = {
3089 NULL
3090 };
3091
3092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3093 {
3094 PyThreadState* __tstate = wxPyBeginAllowThreads();
3095 result = (wxSystemOptions *)new wxSystemOptions();
3096
3097 wxPyEndAllowThreads(__tstate);
3098 if (PyErr_Occurred()) SWIG_fail;
3099 }
3100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxString *arg1 = 0 ;
3110 wxString *arg2 = 0 ;
3111 bool temp1 = false ;
3112 bool temp2 = false ;
3113 PyObject * obj0 = 0 ;
3114 PyObject * obj1 = 0 ;
3115 char *kwnames[] = {
3116 (char *) "name",(char *) "value", NULL
3117 };
3118
3119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3120 {
3121 arg1 = wxString_in_helper(obj0);
3122 if (arg1 == NULL) SWIG_fail;
3123 temp1 = true;
3124 }
3125 {
3126 arg2 = wxString_in_helper(obj1);
3127 if (arg2 == NULL) SWIG_fail;
3128 temp2 = true;
3129 }
3130 {
3131 PyThreadState* __tstate = wxPyBeginAllowThreads();
3132 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3133
3134 wxPyEndAllowThreads(__tstate);
3135 if (PyErr_Occurred()) SWIG_fail;
3136 }
3137 Py_INCREF(Py_None); resultobj = Py_None;
3138 {
3139 if (temp1)
3140 delete arg1;
3141 }
3142 {
3143 if (temp2)
3144 delete arg2;
3145 }
3146 return resultobj;
3147 fail:
3148 {
3149 if (temp1)
3150 delete arg1;
3151 }
3152 {
3153 if (temp2)
3154 delete arg2;
3155 }
3156 return NULL;
3157 }
3158
3159
3160 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3161 PyObject *resultobj;
3162 wxString *arg1 = 0 ;
3163 int arg2 ;
3164 bool temp1 = false ;
3165 PyObject * obj0 = 0 ;
3166 PyObject * obj1 = 0 ;
3167 char *kwnames[] = {
3168 (char *) "name",(char *) "value", NULL
3169 };
3170
3171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3172 {
3173 arg1 = wxString_in_helper(obj0);
3174 if (arg1 == NULL) SWIG_fail;
3175 temp1 = true;
3176 }
3177 {
3178 arg2 = (int)(SWIG_As_int(obj1));
3179 if (SWIG_arg_fail(2)) SWIG_fail;
3180 }
3181 {
3182 PyThreadState* __tstate = wxPyBeginAllowThreads();
3183 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3184
3185 wxPyEndAllowThreads(__tstate);
3186 if (PyErr_Occurred()) SWIG_fail;
3187 }
3188 Py_INCREF(Py_None); resultobj = Py_None;
3189 {
3190 if (temp1)
3191 delete arg1;
3192 }
3193 return resultobj;
3194 fail:
3195 {
3196 if (temp1)
3197 delete arg1;
3198 }
3199 return NULL;
3200 }
3201
3202
3203 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3204 PyObject *resultobj;
3205 wxString *arg1 = 0 ;
3206 wxString result;
3207 bool temp1 = false ;
3208 PyObject * obj0 = 0 ;
3209 char *kwnames[] = {
3210 (char *) "name", NULL
3211 };
3212
3213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3214 {
3215 arg1 = wxString_in_helper(obj0);
3216 if (arg1 == NULL) SWIG_fail;
3217 temp1 = true;
3218 }
3219 {
3220 PyThreadState* __tstate = wxPyBeginAllowThreads();
3221 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3222
3223 wxPyEndAllowThreads(__tstate);
3224 if (PyErr_Occurred()) SWIG_fail;
3225 }
3226 {
3227 #if wxUSE_UNICODE
3228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3229 #else
3230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3231 #endif
3232 }
3233 {
3234 if (temp1)
3235 delete arg1;
3236 }
3237 return resultobj;
3238 fail:
3239 {
3240 if (temp1)
3241 delete arg1;
3242 }
3243 return NULL;
3244 }
3245
3246
3247 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3248 PyObject *resultobj;
3249 wxString *arg1 = 0 ;
3250 int result;
3251 bool temp1 = false ;
3252 PyObject * obj0 = 0 ;
3253 char *kwnames[] = {
3254 (char *) "name", NULL
3255 };
3256
3257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3258 {
3259 arg1 = wxString_in_helper(obj0);
3260 if (arg1 == NULL) SWIG_fail;
3261 temp1 = true;
3262 }
3263 {
3264 PyThreadState* __tstate = wxPyBeginAllowThreads();
3265 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3266
3267 wxPyEndAllowThreads(__tstate);
3268 if (PyErr_Occurred()) SWIG_fail;
3269 }
3270 {
3271 resultobj = SWIG_From_int((int)(result));
3272 }
3273 {
3274 if (temp1)
3275 delete arg1;
3276 }
3277 return resultobj;
3278 fail:
3279 {
3280 if (temp1)
3281 delete arg1;
3282 }
3283 return NULL;
3284 }
3285
3286
3287 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxString *arg1 = 0 ;
3290 bool result;
3291 bool temp1 = false ;
3292 PyObject * obj0 = 0 ;
3293 char *kwnames[] = {
3294 (char *) "name", NULL
3295 };
3296
3297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3298 {
3299 arg1 = wxString_in_helper(obj0);
3300 if (arg1 == NULL) SWIG_fail;
3301 temp1 = true;
3302 }
3303 {
3304 PyThreadState* __tstate = wxPyBeginAllowThreads();
3305 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3306
3307 wxPyEndAllowThreads(__tstate);
3308 if (PyErr_Occurred()) SWIG_fail;
3309 }
3310 {
3311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3312 }
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return resultobj;
3318 fail:
3319 {
3320 if (temp1)
3321 delete arg1;
3322 }
3323 return NULL;
3324 }
3325
3326
3327 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3328 PyObject *obj;
3329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3330 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3331 Py_INCREF(obj);
3332 return Py_BuildValue((char *)"");
3333 }
3334 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3335 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3336 return 1;
3337 }
3338
3339
3340 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3341 PyObject *pyobj;
3342
3343 {
3344 #if wxUSE_UNICODE
3345 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3346 #else
3347 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3348 #endif
3349 }
3350 return pyobj;
3351 }
3352
3353
3354 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3355 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3356 return 1;
3357 }
3358
3359
3360 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3361 PyObject *pyobj;
3362
3363 {
3364 #if wxUSE_UNICODE
3365 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3366 #else
3367 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3368 #endif
3369 }
3370 return pyobj;
3371 }
3372
3373
3374 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3375 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3376 return 1;
3377 }
3378
3379
3380 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3381 PyObject *pyobj;
3382
3383 {
3384 #if wxUSE_UNICODE
3385 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3386 #else
3387 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3388 #endif
3389 }
3390 return pyobj;
3391 }
3392
3393
3394 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 long result;
3397 char *kwnames[] = {
3398 NULL
3399 };
3400
3401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3402 {
3403 PyThreadState* __tstate = wxPyBeginAllowThreads();
3404 result = (long)wxNewId();
3405
3406 wxPyEndAllowThreads(__tstate);
3407 if (PyErr_Occurred()) SWIG_fail;
3408 }
3409 {
3410 resultobj = SWIG_From_long((long)(result));
3411 }
3412 return resultobj;
3413 fail:
3414 return NULL;
3415 }
3416
3417
3418 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3419 PyObject *resultobj;
3420 long arg1 ;
3421 PyObject * obj0 = 0 ;
3422 char *kwnames[] = {
3423 (char *) "id", NULL
3424 };
3425
3426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3427 {
3428 arg1 = (long)(SWIG_As_long(obj0));
3429 if (SWIG_arg_fail(1)) SWIG_fail;
3430 }
3431 {
3432 PyThreadState* __tstate = wxPyBeginAllowThreads();
3433 wxRegisterId(arg1);
3434
3435 wxPyEndAllowThreads(__tstate);
3436 if (PyErr_Occurred()) SWIG_fail;
3437 }
3438 Py_INCREF(Py_None); resultobj = Py_None;
3439 return resultobj;
3440 fail:
3441 return NULL;
3442 }
3443
3444
3445 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3446 PyObject *resultobj;
3447 long result;
3448 char *kwnames[] = {
3449 NULL
3450 };
3451
3452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3453 {
3454 PyThreadState* __tstate = wxPyBeginAllowThreads();
3455 result = (long)wxGetCurrentId();
3456
3457 wxPyEndAllowThreads(__tstate);
3458 if (PyErr_Occurred()) SWIG_fail;
3459 }
3460 {
3461 resultobj = SWIG_From_long((long)(result));
3462 }
3463 return resultobj;
3464 fail:
3465 return NULL;
3466 }
3467
3468
3469 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3470 PyObject *resultobj;
3471 int arg1 ;
3472 bool result;
3473 PyObject * obj0 = 0 ;
3474 char *kwnames[] = {
3475 (char *) "id", NULL
3476 };
3477
3478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3479 {
3480 arg1 = (int)(SWIG_As_int(obj0));
3481 if (SWIG_arg_fail(1)) SWIG_fail;
3482 }
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (bool)wxIsStockID(arg1);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 {
3491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3492 }
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 int arg1 ;
3502 wxString *arg2 = 0 ;
3503 bool result;
3504 bool temp2 = false ;
3505 PyObject * obj0 = 0 ;
3506 PyObject * obj1 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "id",(char *) "label", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3512 {
3513 arg1 = (int)(SWIG_As_int(obj0));
3514 if (SWIG_arg_fail(1)) SWIG_fail;
3515 }
3516 {
3517 arg2 = wxString_in_helper(obj1);
3518 if (arg2 == NULL) SWIG_fail;
3519 temp2 = true;
3520 }
3521 {
3522 PyThreadState* __tstate = wxPyBeginAllowThreads();
3523 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3524
3525 wxPyEndAllowThreads(__tstate);
3526 if (PyErr_Occurred()) SWIG_fail;
3527 }
3528 {
3529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3530 }
3531 {
3532 if (temp2)
3533 delete arg2;
3534 }
3535 return resultobj;
3536 fail:
3537 {
3538 if (temp2)
3539 delete arg2;
3540 }
3541 return NULL;
3542 }
3543
3544
3545 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj;
3547 int arg1 ;
3548 wxString result;
3549 PyObject * obj0 = 0 ;
3550 char *kwnames[] = {
3551 (char *) "id", NULL
3552 };
3553
3554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetStockLabel",kwnames,&obj0)) goto fail;
3555 {
3556 arg1 = (int)(SWIG_As_int(obj0));
3557 if (SWIG_arg_fail(1)) SWIG_fail;
3558 }
3559 {
3560 PyThreadState* __tstate = wxPyBeginAllowThreads();
3561 result = wxGetStockLabel(arg1);
3562
3563 wxPyEndAllowThreads(__tstate);
3564 if (PyErr_Occurred()) SWIG_fail;
3565 }
3566 {
3567 #if wxUSE_UNICODE
3568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3569 #else
3570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3571 #endif
3572 }
3573 return resultobj;
3574 fail:
3575 return NULL;
3576 }
3577
3578
3579 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3580 PyObject *resultobj;
3581 char *kwnames[] = {
3582 NULL
3583 };
3584
3585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3586 {
3587 if (!wxPyCheckForApp()) SWIG_fail;
3588 PyThreadState* __tstate = wxPyBeginAllowThreads();
3589 wxBell();
3590
3591 wxPyEndAllowThreads(__tstate);
3592 if (PyErr_Occurred()) SWIG_fail;
3593 }
3594 Py_INCREF(Py_None); resultobj = Py_None;
3595 return resultobj;
3596 fail:
3597 return NULL;
3598 }
3599
3600
3601 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3602 PyObject *resultobj;
3603 char *kwnames[] = {
3604 NULL
3605 };
3606
3607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3608 {
3609 if (!wxPyCheckForApp()) SWIG_fail;
3610 PyThreadState* __tstate = wxPyBeginAllowThreads();
3611 wxEndBusyCursor();
3612
3613 wxPyEndAllowThreads(__tstate);
3614 if (PyErr_Occurred()) SWIG_fail;
3615 }
3616 Py_INCREF(Py_None); resultobj = Py_None;
3617 return resultobj;
3618 fail:
3619 return NULL;
3620 }
3621
3622
3623 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3624 PyObject *resultobj;
3625 bool arg1 = (bool) true ;
3626 long result;
3627 PyObject * obj0 = 0 ;
3628 char *kwnames[] = {
3629 (char *) "resetTimer", NULL
3630 };
3631
3632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3633 if (obj0) {
3634 {
3635 arg1 = (bool)(SWIG_As_bool(obj0));
3636 if (SWIG_arg_fail(1)) SWIG_fail;
3637 }
3638 }
3639 {
3640 PyThreadState* __tstate = wxPyBeginAllowThreads();
3641 result = (long)wxGetElapsedTime(arg1);
3642
3643 wxPyEndAllowThreads(__tstate);
3644 if (PyErr_Occurred()) SWIG_fail;
3645 }
3646 {
3647 resultobj = SWIG_From_long((long)(result));
3648 }
3649 return resultobj;
3650 fail:
3651 return NULL;
3652 }
3653
3654
3655 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3656 PyObject *resultobj;
3657 int *arg1 = (int *) 0 ;
3658 int *arg2 = (int *) 0 ;
3659 int temp1 ;
3660 int res1 = 0 ;
3661 int temp2 ;
3662 int res2 = 0 ;
3663 char *kwnames[] = {
3664 NULL
3665 };
3666
3667 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3668 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3670 {
3671 if (!wxPyCheckForApp()) SWIG_fail;
3672 PyThreadState* __tstate = wxPyBeginAllowThreads();
3673 wxGetMousePosition(arg1,arg2);
3674
3675 wxPyEndAllowThreads(__tstate);
3676 if (PyErr_Occurred()) SWIG_fail;
3677 }
3678 Py_INCREF(Py_None); resultobj = Py_None;
3679 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3680 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3681 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3682 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3683 return resultobj;
3684 fail:
3685 return NULL;
3686 }
3687
3688
3689 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3690 PyObject *resultobj;
3691 bool result;
3692 char *kwnames[] = {
3693 NULL
3694 };
3695
3696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3697 {
3698 PyThreadState* __tstate = wxPyBeginAllowThreads();
3699 result = (bool)wxIsBusy();
3700
3701 wxPyEndAllowThreads(__tstate);
3702 if (PyErr_Occurred()) SWIG_fail;
3703 }
3704 {
3705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3706 }
3707 return resultobj;
3708 fail:
3709 return NULL;
3710 }
3711
3712
3713 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3714 PyObject *resultobj;
3715 wxString result;
3716 char *kwnames[] = {
3717 NULL
3718 };
3719
3720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3721 {
3722 PyThreadState* __tstate = wxPyBeginAllowThreads();
3723 result = wxNow();
3724
3725 wxPyEndAllowThreads(__tstate);
3726 if (PyErr_Occurred()) SWIG_fail;
3727 }
3728 {
3729 #if wxUSE_UNICODE
3730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3731 #else
3732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3733 #endif
3734 }
3735 return resultobj;
3736 fail:
3737 return NULL;
3738 }
3739
3740
3741 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3742 PyObject *resultobj;
3743 wxString const &arg1_defvalue = wxPyEmptyString ;
3744 wxString *arg1 = (wxString *) &arg1_defvalue ;
3745 bool result;
3746 bool temp1 = false ;
3747 PyObject * obj0 = 0 ;
3748 char *kwnames[] = {
3749 (char *) "command", NULL
3750 };
3751
3752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3753 if (obj0) {
3754 {
3755 arg1 = wxString_in_helper(obj0);
3756 if (arg1 == NULL) SWIG_fail;
3757 temp1 = true;
3758 }
3759 }
3760 {
3761 PyThreadState* __tstate = wxPyBeginAllowThreads();
3762 result = (bool)wxShell((wxString const &)*arg1);
3763
3764 wxPyEndAllowThreads(__tstate);
3765 if (PyErr_Occurred()) SWIG_fail;
3766 }
3767 {
3768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3769 }
3770 {
3771 if (temp1)
3772 delete arg1;
3773 }
3774 return resultobj;
3775 fail:
3776 {
3777 if (temp1)
3778 delete arg1;
3779 }
3780 return NULL;
3781 }
3782
3783
3784 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3785 PyObject *resultobj;
3786 char *kwnames[] = {
3787 NULL
3788 };
3789
3790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3791 {
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 wxStartTimer();
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 Py_INCREF(Py_None); resultobj = Py_None;
3799 return resultobj;
3800 fail:
3801 return NULL;
3802 }
3803
3804
3805 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3806 PyObject *resultobj;
3807 int *arg1 = (int *) 0 ;
3808 int *arg2 = (int *) 0 ;
3809 int result;
3810 int temp1 ;
3811 int res1 = 0 ;
3812 int temp2 ;
3813 int res2 = 0 ;
3814 char *kwnames[] = {
3815 NULL
3816 };
3817
3818 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3819 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (int)wxGetOsVersion(arg1,arg2);
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = SWIG_From_int((int)(result));
3830 }
3831 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3832 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3833 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3834 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxString result;
3844 char *kwnames[] = {
3845 NULL
3846 };
3847
3848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3849 {
3850 PyThreadState* __tstate = wxPyBeginAllowThreads();
3851 result = wxGetOsDescription();
3852
3853 wxPyEndAllowThreads(__tstate);
3854 if (PyErr_Occurred()) SWIG_fail;
3855 }
3856 {
3857 #if wxUSE_UNICODE
3858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3859 #else
3860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3861 #endif
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 long result;
3872 char *kwnames[] = {
3873 NULL
3874 };
3875
3876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3877 {
3878 PyThreadState* __tstate = wxPyBeginAllowThreads();
3879 result = (long)wxGetFreeMemory();
3880
3881 wxPyEndAllowThreads(__tstate);
3882 if (PyErr_Occurred()) SWIG_fail;
3883 }
3884 {
3885 resultobj = SWIG_From_long((long)(result));
3886 }
3887 return resultobj;
3888 fail:
3889 return NULL;
3890 }
3891
3892
3893 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3894 PyObject *resultobj;
3895 wxShutdownFlags arg1 ;
3896 bool result;
3897 PyObject * obj0 = 0 ;
3898 char *kwnames[] = {
3899 (char *) "wFlags", NULL
3900 };
3901
3902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3903 {
3904 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3905 if (SWIG_arg_fail(1)) SWIG_fail;
3906 }
3907 {
3908 if (!wxPyCheckForApp()) SWIG_fail;
3909 PyThreadState* __tstate = wxPyBeginAllowThreads();
3910 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3911
3912 wxPyEndAllowThreads(__tstate);
3913 if (PyErr_Occurred()) SWIG_fail;
3914 }
3915 {
3916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3917 }
3918 return resultobj;
3919 fail:
3920 return NULL;
3921 }
3922
3923
3924 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3925 PyObject *resultobj;
3926 int arg1 ;
3927 PyObject * obj0 = 0 ;
3928 char *kwnames[] = {
3929 (char *) "secs", NULL
3930 };
3931
3932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3933 {
3934 arg1 = (int)(SWIG_As_int(obj0));
3935 if (SWIG_arg_fail(1)) SWIG_fail;
3936 }
3937 {
3938 PyThreadState* __tstate = wxPyBeginAllowThreads();
3939 wxSleep(arg1);
3940
3941 wxPyEndAllowThreads(__tstate);
3942 if (PyErr_Occurred()) SWIG_fail;
3943 }
3944 Py_INCREF(Py_None); resultobj = Py_None;
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3952 PyObject *resultobj;
3953 unsigned long arg1 ;
3954 PyObject * obj0 = 0 ;
3955 char *kwnames[] = {
3956 (char *) "milliseconds", NULL
3957 };
3958
3959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3960 {
3961 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3962 if (SWIG_arg_fail(1)) SWIG_fail;
3963 }
3964 {
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 wxMilliSleep(arg1);
3967
3968 wxPyEndAllowThreads(__tstate);
3969 if (PyErr_Occurred()) SWIG_fail;
3970 }
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 unsigned long arg1 ;
3981 PyObject * obj0 = 0 ;
3982 char *kwnames[] = {
3983 (char *) "microseconds", NULL
3984 };
3985
3986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3987 {
3988 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3989 if (SWIG_arg_fail(1)) SWIG_fail;
3990 }
3991 {
3992 PyThreadState* __tstate = wxPyBeginAllowThreads();
3993 wxMicroSleep(arg1);
3994
3995 wxPyEndAllowThreads(__tstate);
3996 if (PyErr_Occurred()) SWIG_fail;
3997 }
3998 Py_INCREF(Py_None); resultobj = Py_None;
3999 return resultobj;
4000 fail:
4001 return NULL;
4002 }
4003
4004
4005 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4006 PyObject *resultobj;
4007 bool arg1 ;
4008 PyObject * obj0 = 0 ;
4009 char *kwnames[] = {
4010 (char *) "enable", NULL
4011 };
4012
4013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4014 {
4015 arg1 = (bool)(SWIG_As_bool(obj0));
4016 if (SWIG_arg_fail(1)) SWIG_fail;
4017 }
4018 {
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 wxEnableTopLevelWindows(arg1);
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 Py_INCREF(Py_None); resultobj = Py_None;
4026 return resultobj;
4027 fail:
4028 return NULL;
4029 }
4030
4031
4032 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4033 PyObject *resultobj;
4034 wxString *arg1 = 0 ;
4035 wxString result;
4036 bool temp1 = false ;
4037 PyObject * obj0 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "in", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4043 {
4044 arg1 = wxString_in_helper(obj0);
4045 if (arg1 == NULL) SWIG_fail;
4046 temp1 = true;
4047 }
4048 {
4049 PyThreadState* __tstate = wxPyBeginAllowThreads();
4050 result = wxStripMenuCodes((wxString const &)*arg1);
4051
4052 wxPyEndAllowThreads(__tstate);
4053 if (PyErr_Occurred()) SWIG_fail;
4054 }
4055 {
4056 #if wxUSE_UNICODE
4057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4058 #else
4059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4060 #endif
4061 }
4062 {
4063 if (temp1)
4064 delete arg1;
4065 }
4066 return resultobj;
4067 fail:
4068 {
4069 if (temp1)
4070 delete arg1;
4071 }
4072 return NULL;
4073 }
4074
4075
4076 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4077 PyObject *resultobj;
4078 wxString result;
4079 char *kwnames[] = {
4080 NULL
4081 };
4082
4083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4084 {
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 result = wxGetEmailAddress();
4087
4088 wxPyEndAllowThreads(__tstate);
4089 if (PyErr_Occurred()) SWIG_fail;
4090 }
4091 {
4092 #if wxUSE_UNICODE
4093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4094 #else
4095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4096 #endif
4097 }
4098 return resultobj;
4099 fail:
4100 return NULL;
4101 }
4102
4103
4104 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4105 PyObject *resultobj;
4106 wxString result;
4107 char *kwnames[] = {
4108 NULL
4109 };
4110
4111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = wxGetHostName();
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 {
4120 #if wxUSE_UNICODE
4121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4122 #else
4123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4124 #endif
4125 }
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj;
4134 wxString result;
4135 char *kwnames[] = {
4136 NULL
4137 };
4138
4139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4140 {
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 result = wxGetFullHostName();
4143
4144 wxPyEndAllowThreads(__tstate);
4145 if (PyErr_Occurred()) SWIG_fail;
4146 }
4147 {
4148 #if wxUSE_UNICODE
4149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4150 #else
4151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4152 #endif
4153 }
4154 return resultobj;
4155 fail:
4156 return NULL;
4157 }
4158
4159
4160 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4161 PyObject *resultobj;
4162 wxString result;
4163 char *kwnames[] = {
4164 NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4168 {
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = wxGetUserId();
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 {
4176 #if wxUSE_UNICODE
4177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4178 #else
4179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4180 #endif
4181 }
4182 return resultobj;
4183 fail:
4184 return NULL;
4185 }
4186
4187
4188 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4189 PyObject *resultobj;
4190 wxString result;
4191 char *kwnames[] = {
4192 NULL
4193 };
4194
4195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4196 {
4197 PyThreadState* __tstate = wxPyBeginAllowThreads();
4198 result = wxGetUserName();
4199
4200 wxPyEndAllowThreads(__tstate);
4201 if (PyErr_Occurred()) SWIG_fail;
4202 }
4203 {
4204 #if wxUSE_UNICODE
4205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4206 #else
4207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4208 #endif
4209 }
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj;
4218 wxString result;
4219 char *kwnames[] = {
4220 NULL
4221 };
4222
4223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4224 {
4225 PyThreadState* __tstate = wxPyBeginAllowThreads();
4226 result = wxGetHomeDir();
4227
4228 wxPyEndAllowThreads(__tstate);
4229 if (PyErr_Occurred()) SWIG_fail;
4230 }
4231 {
4232 #if wxUSE_UNICODE
4233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4234 #else
4235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4236 #endif
4237 }
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj;
4246 wxString const &arg1_defvalue = wxPyEmptyString ;
4247 wxString *arg1 = (wxString *) &arg1_defvalue ;
4248 wxString result;
4249 bool temp1 = false ;
4250 PyObject * obj0 = 0 ;
4251 char *kwnames[] = {
4252 (char *) "user", NULL
4253 };
4254
4255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4256 if (obj0) {
4257 {
4258 arg1 = wxString_in_helper(obj0);
4259 if (arg1 == NULL) SWIG_fail;
4260 temp1 = true;
4261 }
4262 }
4263 {
4264 PyThreadState* __tstate = wxPyBeginAllowThreads();
4265 result = wxGetUserHome((wxString const &)*arg1);
4266
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 {
4271 #if wxUSE_UNICODE
4272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4273 #else
4274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4275 #endif
4276 }
4277 {
4278 if (temp1)
4279 delete arg1;
4280 }
4281 return resultobj;
4282 fail:
4283 {
4284 if (temp1)
4285 delete arg1;
4286 }
4287 return NULL;
4288 }
4289
4290
4291 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4292 PyObject *resultobj;
4293 unsigned long result;
4294 char *kwnames[] = {
4295 NULL
4296 };
4297
4298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4299 {
4300 PyThreadState* __tstate = wxPyBeginAllowThreads();
4301 result = (unsigned long)wxGetProcessId();
4302
4303 wxPyEndAllowThreads(__tstate);
4304 if (PyErr_Occurred()) SWIG_fail;
4305 }
4306 {
4307 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4308 }
4309 return resultobj;
4310 fail:
4311 return NULL;
4312 }
4313
4314
4315 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4316 PyObject *resultobj;
4317 char *kwnames[] = {
4318 NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4322 {
4323 PyThreadState* __tstate = wxPyBeginAllowThreads();
4324 wxTrap();
4325
4326 wxPyEndAllowThreads(__tstate);
4327 if (PyErr_Occurred()) SWIG_fail;
4328 }
4329 Py_INCREF(Py_None); resultobj = Py_None;
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4337 PyObject *resultobj;
4338 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4339 wxString *arg1 = (wxString *) &arg1_defvalue ;
4340 wxString const &arg2_defvalue = wxPyEmptyString ;
4341 wxString *arg2 = (wxString *) &arg2_defvalue ;
4342 wxString const &arg3_defvalue = wxPyEmptyString ;
4343 wxString *arg3 = (wxString *) &arg3_defvalue ;
4344 wxString const &arg4_defvalue = wxPyEmptyString ;
4345 wxString *arg4 = (wxString *) &arg4_defvalue ;
4346 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4347 wxString *arg5 = (wxString *) &arg5_defvalue ;
4348 int arg6 = (int) 0 ;
4349 wxWindow *arg7 = (wxWindow *) NULL ;
4350 int arg8 = (int) -1 ;
4351 int arg9 = (int) -1 ;
4352 wxString result;
4353 bool temp1 = false ;
4354 bool temp2 = false ;
4355 bool temp3 = false ;
4356 bool temp4 = false ;
4357 bool temp5 = false ;
4358 PyObject * obj0 = 0 ;
4359 PyObject * obj1 = 0 ;
4360 PyObject * obj2 = 0 ;
4361 PyObject * obj3 = 0 ;
4362 PyObject * obj4 = 0 ;
4363 PyObject * obj5 = 0 ;
4364 PyObject * obj6 = 0 ;
4365 PyObject * obj7 = 0 ;
4366 PyObject * obj8 = 0 ;
4367 char *kwnames[] = {
4368 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4369 };
4370
4371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4372 if (obj0) {
4373 {
4374 arg1 = wxString_in_helper(obj0);
4375 if (arg1 == NULL) SWIG_fail;
4376 temp1 = true;
4377 }
4378 }
4379 if (obj1) {
4380 {
4381 arg2 = wxString_in_helper(obj1);
4382 if (arg2 == NULL) SWIG_fail;
4383 temp2 = true;
4384 }
4385 }
4386 if (obj2) {
4387 {
4388 arg3 = wxString_in_helper(obj2);
4389 if (arg3 == NULL) SWIG_fail;
4390 temp3 = true;
4391 }
4392 }
4393 if (obj3) {
4394 {
4395 arg4 = wxString_in_helper(obj3);
4396 if (arg4 == NULL) SWIG_fail;
4397 temp4 = true;
4398 }
4399 }
4400 if (obj4) {
4401 {
4402 arg5 = wxString_in_helper(obj4);
4403 if (arg5 == NULL) SWIG_fail;
4404 temp5 = true;
4405 }
4406 }
4407 if (obj5) {
4408 {
4409 arg6 = (int)(SWIG_As_int(obj5));
4410 if (SWIG_arg_fail(6)) SWIG_fail;
4411 }
4412 }
4413 if (obj6) {
4414 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4415 if (SWIG_arg_fail(7)) SWIG_fail;
4416 }
4417 if (obj7) {
4418 {
4419 arg8 = (int)(SWIG_As_int(obj7));
4420 if (SWIG_arg_fail(8)) SWIG_fail;
4421 }
4422 }
4423 if (obj8) {
4424 {
4425 arg9 = (int)(SWIG_As_int(obj8));
4426 if (SWIG_arg_fail(9)) SWIG_fail;
4427 }
4428 }
4429 {
4430 if (!wxPyCheckForApp()) SWIG_fail;
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4433
4434 wxPyEndAllowThreads(__tstate);
4435 if (PyErr_Occurred()) SWIG_fail;
4436 }
4437 {
4438 #if wxUSE_UNICODE
4439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4440 #else
4441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4442 #endif
4443 }
4444 {
4445 if (temp1)
4446 delete arg1;
4447 }
4448 {
4449 if (temp2)
4450 delete arg2;
4451 }
4452 {
4453 if (temp3)
4454 delete arg3;
4455 }
4456 {
4457 if (temp4)
4458 delete arg4;
4459 }
4460 {
4461 if (temp5)
4462 delete arg5;
4463 }
4464 return resultobj;
4465 fail:
4466 {
4467 if (temp1)
4468 delete arg1;
4469 }
4470 {
4471 if (temp2)
4472 delete arg2;
4473 }
4474 {
4475 if (temp3)
4476 delete arg3;
4477 }
4478 {
4479 if (temp4)
4480 delete arg4;
4481 }
4482 {
4483 if (temp5)
4484 delete arg5;
4485 }
4486 return NULL;
4487 }
4488
4489
4490 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4491 PyObject *resultobj;
4492 wxString *arg1 = 0 ;
4493 wxString *arg2 = 0 ;
4494 wxString const &arg3_defvalue = wxPyEmptyString ;
4495 wxString *arg3 = (wxString *) &arg3_defvalue ;
4496 wxWindow *arg4 = (wxWindow *) NULL ;
4497 wxString result;
4498 bool temp1 = false ;
4499 bool temp2 = false ;
4500 bool temp3 = false ;
4501 PyObject * obj0 = 0 ;
4502 PyObject * obj1 = 0 ;
4503 PyObject * obj2 = 0 ;
4504 PyObject * obj3 = 0 ;
4505 char *kwnames[] = {
4506 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4507 };
4508
4509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4510 {
4511 arg1 = wxString_in_helper(obj0);
4512 if (arg1 == NULL) SWIG_fail;
4513 temp1 = true;
4514 }
4515 {
4516 arg2 = wxString_in_helper(obj1);
4517 if (arg2 == NULL) SWIG_fail;
4518 temp2 = true;
4519 }
4520 if (obj2) {
4521 {
4522 arg3 = wxString_in_helper(obj2);
4523 if (arg3 == NULL) SWIG_fail;
4524 temp3 = true;
4525 }
4526 }
4527 if (obj3) {
4528 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4529 if (SWIG_arg_fail(4)) SWIG_fail;
4530 }
4531 {
4532 if (!wxPyCheckForApp()) SWIG_fail;
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4535
4536 wxPyEndAllowThreads(__tstate);
4537 if (PyErr_Occurred()) SWIG_fail;
4538 }
4539 {
4540 #if wxUSE_UNICODE
4541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4542 #else
4543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4544 #endif
4545 }
4546 {
4547 if (temp1)
4548 delete arg1;
4549 }
4550 {
4551 if (temp2)
4552 delete arg2;
4553 }
4554 {
4555 if (temp3)
4556 delete arg3;
4557 }
4558 return resultobj;
4559 fail:
4560 {
4561 if (temp1)
4562 delete arg1;
4563 }
4564 {
4565 if (temp2)
4566 delete arg2;
4567 }
4568 {
4569 if (temp3)
4570 delete arg3;
4571 }
4572 return NULL;
4573 }
4574
4575
4576 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj;
4578 wxString *arg1 = 0 ;
4579 wxString *arg2 = 0 ;
4580 wxString const &arg3_defvalue = wxPyEmptyString ;
4581 wxString *arg3 = (wxString *) &arg3_defvalue ;
4582 wxWindow *arg4 = (wxWindow *) NULL ;
4583 wxString result;
4584 bool temp1 = false ;
4585 bool temp2 = false ;
4586 bool temp3 = false ;
4587 PyObject * obj0 = 0 ;
4588 PyObject * obj1 = 0 ;
4589 PyObject * obj2 = 0 ;
4590 PyObject * obj3 = 0 ;
4591 char *kwnames[] = {
4592 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4593 };
4594
4595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4596 {
4597 arg1 = wxString_in_helper(obj0);
4598 if (arg1 == NULL) SWIG_fail;
4599 temp1 = true;
4600 }
4601 {
4602 arg2 = wxString_in_helper(obj1);
4603 if (arg2 == NULL) SWIG_fail;
4604 temp2 = true;
4605 }
4606 if (obj2) {
4607 {
4608 arg3 = wxString_in_helper(obj2);
4609 if (arg3 == NULL) SWIG_fail;
4610 temp3 = true;
4611 }
4612 }
4613 if (obj3) {
4614 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4615 if (SWIG_arg_fail(4)) SWIG_fail;
4616 }
4617 {
4618 if (!wxPyCheckForApp()) SWIG_fail;
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4621
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 {
4626 #if wxUSE_UNICODE
4627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4628 #else
4629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4630 #endif
4631 }
4632 {
4633 if (temp1)
4634 delete arg1;
4635 }
4636 {
4637 if (temp2)
4638 delete arg2;
4639 }
4640 {
4641 if (temp3)
4642 delete arg3;
4643 }
4644 return resultobj;
4645 fail:
4646 {
4647 if (temp1)
4648 delete arg1;
4649 }
4650 {
4651 if (temp2)
4652 delete arg2;
4653 }
4654 {
4655 if (temp3)
4656 delete arg3;
4657 }
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4665 wxString *arg1 = (wxString *) &arg1_defvalue ;
4666 wxString const &arg2_defvalue = wxPyEmptyString ;
4667 wxString *arg2 = (wxString *) &arg2_defvalue ;
4668 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4669 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4670 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4671 wxWindow *arg5 = (wxWindow *) NULL ;
4672 wxString result;
4673 bool temp1 = false ;
4674 bool temp2 = false ;
4675 wxPoint temp4 ;
4676 PyObject * obj0 = 0 ;
4677 PyObject * obj1 = 0 ;
4678 PyObject * obj2 = 0 ;
4679 PyObject * obj3 = 0 ;
4680 PyObject * obj4 = 0 ;
4681 char *kwnames[] = {
4682 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4683 };
4684
4685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4686 if (obj0) {
4687 {
4688 arg1 = wxString_in_helper(obj0);
4689 if (arg1 == NULL) SWIG_fail;
4690 temp1 = true;
4691 }
4692 }
4693 if (obj1) {
4694 {
4695 arg2 = wxString_in_helper(obj1);
4696 if (arg2 == NULL) SWIG_fail;
4697 temp2 = true;
4698 }
4699 }
4700 if (obj2) {
4701 {
4702 arg3 = (long)(SWIG_As_long(obj2));
4703 if (SWIG_arg_fail(3)) SWIG_fail;
4704 }
4705 }
4706 if (obj3) {
4707 {
4708 arg4 = &temp4;
4709 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4710 }
4711 }
4712 if (obj4) {
4713 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4714 if (SWIG_arg_fail(5)) SWIG_fail;
4715 }
4716 {
4717 if (!wxPyCheckForApp()) SWIG_fail;
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4720
4721 wxPyEndAllowThreads(__tstate);
4722 if (PyErr_Occurred()) SWIG_fail;
4723 }
4724 {
4725 #if wxUSE_UNICODE
4726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4727 #else
4728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4729 #endif
4730 }
4731 {
4732 if (temp1)
4733 delete arg1;
4734 }
4735 {
4736 if (temp2)
4737 delete arg2;
4738 }
4739 return resultobj;
4740 fail:
4741 {
4742 if (temp1)
4743 delete arg1;
4744 }
4745 {
4746 if (temp2)
4747 delete arg2;
4748 }
4749 return NULL;
4750 }
4751
4752
4753 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj;
4755 wxString *arg1 = 0 ;
4756 wxString const &arg2_defvalue = wxPyEmptyString ;
4757 wxString *arg2 = (wxString *) &arg2_defvalue ;
4758 wxString const &arg3_defvalue = wxPyEmptyString ;
4759 wxString *arg3 = (wxString *) &arg3_defvalue ;
4760 wxWindow *arg4 = (wxWindow *) NULL ;
4761 int arg5 = (int) -1 ;
4762 int arg6 = (int) -1 ;
4763 bool arg7 = (bool) true ;
4764 wxString result;
4765 bool temp1 = false ;
4766 bool temp2 = false ;
4767 bool temp3 = false ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 PyObject * obj2 = 0 ;
4771 PyObject * obj3 = 0 ;
4772 PyObject * obj4 = 0 ;
4773 PyObject * obj5 = 0 ;
4774 PyObject * obj6 = 0 ;
4775 char *kwnames[] = {
4776 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4777 };
4778
4779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4780 {
4781 arg1 = wxString_in_helper(obj0);
4782 if (arg1 == NULL) SWIG_fail;
4783 temp1 = true;
4784 }
4785 if (obj1) {
4786 {
4787 arg2 = wxString_in_helper(obj1);
4788 if (arg2 == NULL) SWIG_fail;
4789 temp2 = true;
4790 }
4791 }
4792 if (obj2) {
4793 {
4794 arg3 = wxString_in_helper(obj2);
4795 if (arg3 == NULL) SWIG_fail;
4796 temp3 = true;
4797 }
4798 }
4799 if (obj3) {
4800 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4801 if (SWIG_arg_fail(4)) SWIG_fail;
4802 }
4803 if (obj4) {
4804 {
4805 arg5 = (int)(SWIG_As_int(obj4));
4806 if (SWIG_arg_fail(5)) SWIG_fail;
4807 }
4808 }
4809 if (obj5) {
4810 {
4811 arg6 = (int)(SWIG_As_int(obj5));
4812 if (SWIG_arg_fail(6)) SWIG_fail;
4813 }
4814 }
4815 if (obj6) {
4816 {
4817 arg7 = (bool)(SWIG_As_bool(obj6));
4818 if (SWIG_arg_fail(7)) SWIG_fail;
4819 }
4820 }
4821 {
4822 if (!wxPyCheckForApp()) SWIG_fail;
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4825
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 {
4830 #if wxUSE_UNICODE
4831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4832 #else
4833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4834 #endif
4835 }
4836 {
4837 if (temp1)
4838 delete arg1;
4839 }
4840 {
4841 if (temp2)
4842 delete arg2;
4843 }
4844 {
4845 if (temp3)
4846 delete arg3;
4847 }
4848 return resultobj;
4849 fail:
4850 {
4851 if (temp1)
4852 delete arg1;
4853 }
4854 {
4855 if (temp2)
4856 delete arg2;
4857 }
4858 {
4859 if (temp3)
4860 delete arg3;
4861 }
4862 return NULL;
4863 }
4864
4865
4866 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxString *arg1 = 0 ;
4869 wxString const &arg2_defvalue = wxPyEmptyString ;
4870 wxString *arg2 = (wxString *) &arg2_defvalue ;
4871 wxString const &arg3_defvalue = wxPyEmptyString ;
4872 wxString *arg3 = (wxString *) &arg3_defvalue ;
4873 wxWindow *arg4 = (wxWindow *) NULL ;
4874 wxString result;
4875 bool temp1 = false ;
4876 bool temp2 = false ;
4877 bool temp3 = false ;
4878 PyObject * obj0 = 0 ;
4879 PyObject * obj1 = 0 ;
4880 PyObject * obj2 = 0 ;
4881 PyObject * obj3 = 0 ;
4882 char *kwnames[] = {
4883 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4884 };
4885
4886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4887 {
4888 arg1 = wxString_in_helper(obj0);
4889 if (arg1 == NULL) SWIG_fail;
4890 temp1 = true;
4891 }
4892 if (obj1) {
4893 {
4894 arg2 = wxString_in_helper(obj1);
4895 if (arg2 == NULL) SWIG_fail;
4896 temp2 = true;
4897 }
4898 }
4899 if (obj2) {
4900 {
4901 arg3 = wxString_in_helper(obj2);
4902 if (arg3 == NULL) SWIG_fail;
4903 temp3 = true;
4904 }
4905 }
4906 if (obj3) {
4907 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4908 if (SWIG_arg_fail(4)) SWIG_fail;
4909 }
4910 {
4911 if (!wxPyCheckForApp()) SWIG_fail;
4912 PyThreadState* __tstate = wxPyBeginAllowThreads();
4913 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4914
4915 wxPyEndAllowThreads(__tstate);
4916 if (PyErr_Occurred()) SWIG_fail;
4917 }
4918 {
4919 #if wxUSE_UNICODE
4920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4921 #else
4922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4923 #endif
4924 }
4925 {
4926 if (temp1)
4927 delete arg1;
4928 }
4929 {
4930 if (temp2)
4931 delete arg2;
4932 }
4933 {
4934 if (temp3)
4935 delete arg3;
4936 }
4937 return resultobj;
4938 fail:
4939 {
4940 if (temp1)
4941 delete arg1;
4942 }
4943 {
4944 if (temp2)
4945 delete arg2;
4946 }
4947 {
4948 if (temp3)
4949 delete arg3;
4950 }
4951 return NULL;
4952 }
4953
4954
4955 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4956 PyObject *resultobj;
4957 wxString *arg1 = 0 ;
4958 wxString *arg2 = 0 ;
4959 int arg3 ;
4960 wxString *arg4 = (wxString *) 0 ;
4961 wxWindow *arg5 = (wxWindow *) NULL ;
4962 int arg6 = (int) -1 ;
4963 int arg7 = (int) -1 ;
4964 bool arg8 = (bool) true ;
4965 int arg9 = (int) 150 ;
4966 int arg10 = (int) 200 ;
4967 wxString result;
4968 bool temp1 = false ;
4969 bool temp2 = false ;
4970 PyObject * obj0 = 0 ;
4971 PyObject * obj1 = 0 ;
4972 PyObject * obj2 = 0 ;
4973 PyObject * obj3 = 0 ;
4974 PyObject * obj4 = 0 ;
4975 PyObject * obj5 = 0 ;
4976 PyObject * obj6 = 0 ;
4977 PyObject * obj7 = 0 ;
4978 PyObject * obj8 = 0 ;
4979 char *kwnames[] = {
4980 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4981 };
4982
4983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4984 {
4985 arg1 = wxString_in_helper(obj0);
4986 if (arg1 == NULL) SWIG_fail;
4987 temp1 = true;
4988 }
4989 {
4990 arg2 = wxString_in_helper(obj1);
4991 if (arg2 == NULL) SWIG_fail;
4992 temp2 = true;
4993 }
4994 {
4995 arg3 = PyList_Size(obj2);
4996 arg4 = wxString_LIST_helper(obj2);
4997 if (arg4 == NULL) SWIG_fail;
4998 }
4999 if (obj3) {
5000 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5001 if (SWIG_arg_fail(5)) SWIG_fail;
5002 }
5003 if (obj4) {
5004 {
5005 arg6 = (int)(SWIG_As_int(obj4));
5006 if (SWIG_arg_fail(6)) SWIG_fail;
5007 }
5008 }
5009 if (obj5) {
5010 {
5011 arg7 = (int)(SWIG_As_int(obj5));
5012 if (SWIG_arg_fail(7)) SWIG_fail;
5013 }
5014 }
5015 if (obj6) {
5016 {
5017 arg8 = (bool)(SWIG_As_bool(obj6));
5018 if (SWIG_arg_fail(8)) SWIG_fail;
5019 }
5020 }
5021 if (obj7) {
5022 {
5023 arg9 = (int)(SWIG_As_int(obj7));
5024 if (SWIG_arg_fail(9)) SWIG_fail;
5025 }
5026 }
5027 if (obj8) {
5028 {
5029 arg10 = (int)(SWIG_As_int(obj8));
5030 if (SWIG_arg_fail(10)) SWIG_fail;
5031 }
5032 }
5033 {
5034 if (!wxPyCheckForApp()) SWIG_fail;
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5037
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 {
5042 #if wxUSE_UNICODE
5043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5044 #else
5045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5046 #endif
5047 }
5048 {
5049 if (temp1)
5050 delete arg1;
5051 }
5052 {
5053 if (temp2)
5054 delete arg2;
5055 }
5056 {
5057 if (arg4) delete [] arg4;
5058 }
5059 return resultobj;
5060 fail:
5061 {
5062 if (temp1)
5063 delete arg1;
5064 }
5065 {
5066 if (temp2)
5067 delete arg2;
5068 }
5069 {
5070 if (arg4) delete [] arg4;
5071 }
5072 return NULL;
5073 }
5074
5075
5076 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5077 PyObject *resultobj;
5078 wxString *arg1 = 0 ;
5079 wxString *arg2 = 0 ;
5080 int arg3 ;
5081 wxString *arg4 = (wxString *) 0 ;
5082 wxWindow *arg5 = (wxWindow *) NULL ;
5083 int arg6 = (int) -1 ;
5084 int arg7 = (int) -1 ;
5085 bool arg8 = (bool) true ;
5086 int arg9 = (int) 150 ;
5087 int arg10 = (int) 200 ;
5088 int result;
5089 bool temp1 = false ;
5090 bool temp2 = false ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 PyObject * obj3 = 0 ;
5095 PyObject * obj4 = 0 ;
5096 PyObject * obj5 = 0 ;
5097 PyObject * obj6 = 0 ;
5098 PyObject * obj7 = 0 ;
5099 PyObject * obj8 = 0 ;
5100 char *kwnames[] = {
5101 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5102 };
5103
5104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5105 {
5106 arg1 = wxString_in_helper(obj0);
5107 if (arg1 == NULL) SWIG_fail;
5108 temp1 = true;
5109 }
5110 {
5111 arg2 = wxString_in_helper(obj1);
5112 if (arg2 == NULL) SWIG_fail;
5113 temp2 = true;
5114 }
5115 {
5116 arg3 = PyList_Size(obj2);
5117 arg4 = wxString_LIST_helper(obj2);
5118 if (arg4 == NULL) SWIG_fail;
5119 }
5120 if (obj3) {
5121 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(5)) SWIG_fail;
5123 }
5124 if (obj4) {
5125 {
5126 arg6 = (int)(SWIG_As_int(obj4));
5127 if (SWIG_arg_fail(6)) SWIG_fail;
5128 }
5129 }
5130 if (obj5) {
5131 {
5132 arg7 = (int)(SWIG_As_int(obj5));
5133 if (SWIG_arg_fail(7)) SWIG_fail;
5134 }
5135 }
5136 if (obj6) {
5137 {
5138 arg8 = (bool)(SWIG_As_bool(obj6));
5139 if (SWIG_arg_fail(8)) SWIG_fail;
5140 }
5141 }
5142 if (obj7) {
5143 {
5144 arg9 = (int)(SWIG_As_int(obj7));
5145 if (SWIG_arg_fail(9)) SWIG_fail;
5146 }
5147 }
5148 if (obj8) {
5149 {
5150 arg10 = (int)(SWIG_As_int(obj8));
5151 if (SWIG_arg_fail(10)) SWIG_fail;
5152 }
5153 }
5154 {
5155 if (!wxPyCheckForApp()) SWIG_fail;
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 {
5163 resultobj = SWIG_From_int((int)(result));
5164 }
5165 {
5166 if (temp1)
5167 delete arg1;
5168 }
5169 {
5170 if (temp2)
5171 delete arg2;
5172 }
5173 {
5174 if (arg4) delete [] arg4;
5175 }
5176 return resultobj;
5177 fail:
5178 {
5179 if (temp1)
5180 delete arg1;
5181 }
5182 {
5183 if (temp2)
5184 delete arg2;
5185 }
5186 {
5187 if (arg4) delete [] arg4;
5188 }
5189 return NULL;
5190 }
5191
5192
5193 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj;
5195 wxString *arg1 = 0 ;
5196 wxString const &arg2_defvalue = wxPyEmptyString ;
5197 wxString *arg2 = (wxString *) &arg2_defvalue ;
5198 int arg3 = (int) wxOK|wxCENTRE ;
5199 wxWindow *arg4 = (wxWindow *) NULL ;
5200 int arg5 = (int) -1 ;
5201 int arg6 = (int) -1 ;
5202 int result;
5203 bool temp1 = false ;
5204 bool temp2 = false ;
5205 PyObject * obj0 = 0 ;
5206 PyObject * obj1 = 0 ;
5207 PyObject * obj2 = 0 ;
5208 PyObject * obj3 = 0 ;
5209 PyObject * obj4 = 0 ;
5210 PyObject * obj5 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5216 {
5217 arg1 = wxString_in_helper(obj0);
5218 if (arg1 == NULL) SWIG_fail;
5219 temp1 = true;
5220 }
5221 if (obj1) {
5222 {
5223 arg2 = wxString_in_helper(obj1);
5224 if (arg2 == NULL) SWIG_fail;
5225 temp2 = true;
5226 }
5227 }
5228 if (obj2) {
5229 {
5230 arg3 = (int)(SWIG_As_int(obj2));
5231 if (SWIG_arg_fail(3)) SWIG_fail;
5232 }
5233 }
5234 if (obj3) {
5235 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5236 if (SWIG_arg_fail(4)) SWIG_fail;
5237 }
5238 if (obj4) {
5239 {
5240 arg5 = (int)(SWIG_As_int(obj4));
5241 if (SWIG_arg_fail(5)) SWIG_fail;
5242 }
5243 }
5244 if (obj5) {
5245 {
5246 arg6 = (int)(SWIG_As_int(obj5));
5247 if (SWIG_arg_fail(6)) SWIG_fail;
5248 }
5249 }
5250 {
5251 if (!wxPyCheckForApp()) SWIG_fail;
5252 PyThreadState* __tstate = wxPyBeginAllowThreads();
5253 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5254
5255 wxPyEndAllowThreads(__tstate);
5256 if (PyErr_Occurred()) SWIG_fail;
5257 }
5258 {
5259 resultobj = SWIG_From_int((int)(result));
5260 }
5261 {
5262 if (temp1)
5263 delete arg1;
5264 }
5265 {
5266 if (temp2)
5267 delete arg2;
5268 }
5269 return resultobj;
5270 fail:
5271 {
5272 if (temp1)
5273 delete arg1;
5274 }
5275 {
5276 if (temp2)
5277 delete arg2;
5278 }
5279 return NULL;
5280 }
5281
5282
5283 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj;
5285 wxString *arg1 = 0 ;
5286 wxString *arg2 = 0 ;
5287 wxString *arg3 = 0 ;
5288 long arg4 ;
5289 long arg5 = (long) 0 ;
5290 long arg6 = (long) 100 ;
5291 wxWindow *arg7 = (wxWindow *) NULL ;
5292 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5293 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5294 long result;
5295 bool temp1 = false ;
5296 bool temp2 = false ;
5297 bool temp3 = false ;
5298 wxPoint temp8 ;
5299 PyObject * obj0 = 0 ;
5300 PyObject * obj1 = 0 ;
5301 PyObject * obj2 = 0 ;
5302 PyObject * obj3 = 0 ;
5303 PyObject * obj4 = 0 ;
5304 PyObject * obj5 = 0 ;
5305 PyObject * obj6 = 0 ;
5306 PyObject * obj7 = 0 ;
5307 char *kwnames[] = {
5308 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5309 };
5310
5311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5312 {
5313 arg1 = wxString_in_helper(obj0);
5314 if (arg1 == NULL) SWIG_fail;
5315 temp1 = true;
5316 }
5317 {
5318 arg2 = wxString_in_helper(obj1);
5319 if (arg2 == NULL) SWIG_fail;
5320 temp2 = true;
5321 }
5322 {
5323 arg3 = wxString_in_helper(obj2);
5324 if (arg3 == NULL) SWIG_fail;
5325 temp3 = true;
5326 }
5327 {
5328 arg4 = (long)(SWIG_As_long(obj3));
5329 if (SWIG_arg_fail(4)) SWIG_fail;
5330 }
5331 if (obj4) {
5332 {
5333 arg5 = (long)(SWIG_As_long(obj4));
5334 if (SWIG_arg_fail(5)) SWIG_fail;
5335 }
5336 }
5337 if (obj5) {
5338 {
5339 arg6 = (long)(SWIG_As_long(obj5));
5340 if (SWIG_arg_fail(6)) SWIG_fail;
5341 }
5342 }
5343 if (obj6) {
5344 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(7)) SWIG_fail;
5346 }
5347 if (obj7) {
5348 {
5349 arg8 = &temp8;
5350 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5351 }
5352 }
5353 {
5354 if (!wxPyCheckForApp()) SWIG_fail;
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 resultobj = SWIG_From_long((long)(result));
5363 }
5364 {
5365 if (temp1)
5366 delete arg1;
5367 }
5368 {
5369 if (temp2)
5370 delete arg2;
5371 }
5372 {
5373 if (temp3)
5374 delete arg3;
5375 }
5376 return resultobj;
5377 fail:
5378 {
5379 if (temp1)
5380 delete arg1;
5381 }
5382 {
5383 if (temp2)
5384 delete arg2;
5385 }
5386 {
5387 if (temp3)
5388 delete arg3;
5389 }
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 bool result;
5397 char *kwnames[] = {
5398 NULL
5399 };
5400
5401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5402 {
5403 if (!wxPyCheckForApp()) SWIG_fail;
5404 PyThreadState* __tstate = wxPyBeginAllowThreads();
5405 result = (bool)wxColourDisplay();
5406
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 {
5411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5412 }
5413 return resultobj;
5414 fail:
5415 return NULL;
5416 }
5417
5418
5419 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5420 PyObject *resultobj;
5421 int result;
5422 char *kwnames[] = {
5423 NULL
5424 };
5425
5426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5427 {
5428 if (!wxPyCheckForApp()) SWIG_fail;
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (int)wxDisplayDepth();
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 resultobj = SWIG_From_int((int)(result));
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj;
5446 int result;
5447 char *kwnames[] = {
5448 NULL
5449 };
5450
5451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5452 {
5453 if (!wxPyCheckForApp()) SWIG_fail;
5454 PyThreadState* __tstate = wxPyBeginAllowThreads();
5455 result = (int)wxGetDisplayDepth();
5456
5457 wxPyEndAllowThreads(__tstate);
5458 if (PyErr_Occurred()) SWIG_fail;
5459 }
5460 {
5461 resultobj = SWIG_From_int((int)(result));
5462 }
5463 return resultobj;
5464 fail:
5465 return NULL;
5466 }
5467
5468
5469 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5470 PyObject *resultobj;
5471 int *arg1 = (int *) 0 ;
5472 int *arg2 = (int *) 0 ;
5473 int temp1 ;
5474 int res1 = 0 ;
5475 int temp2 ;
5476 int res2 = 0 ;
5477 char *kwnames[] = {
5478 NULL
5479 };
5480
5481 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5482 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5484 {
5485 if (!wxPyCheckForApp()) SWIG_fail;
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 wxDisplaySize(arg1,arg2);
5488
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 Py_INCREF(Py_None); resultobj = Py_None;
5493 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5494 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5495 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5496 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5497 return resultobj;
5498 fail:
5499 return NULL;
5500 }
5501
5502
5503 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5504 PyObject *resultobj;
5505 wxSize result;
5506 char *kwnames[] = {
5507 NULL
5508 };
5509
5510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5511 {
5512 if (!wxPyCheckForApp()) SWIG_fail;
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = wxGetDisplaySize();
5515
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 {
5520 wxSize * resultptr;
5521 resultptr = new wxSize((wxSize &)(result));
5522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5523 }
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5531 PyObject *resultobj;
5532 int *arg1 = (int *) 0 ;
5533 int *arg2 = (int *) 0 ;
5534 int temp1 ;
5535 int res1 = 0 ;
5536 int temp2 ;
5537 int res2 = 0 ;
5538 char *kwnames[] = {
5539 NULL
5540 };
5541
5542 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5543 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5545 {
5546 if (!wxPyCheckForApp()) SWIG_fail;
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 wxDisplaySizeMM(arg1,arg2);
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 Py_INCREF(Py_None); resultobj = Py_None;
5554 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5555 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5556 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5557 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5565 PyObject *resultobj;
5566 wxSize result;
5567 char *kwnames[] = {
5568 NULL
5569 };
5570
5571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5572 {
5573 if (!wxPyCheckForApp()) SWIG_fail;
5574 PyThreadState* __tstate = wxPyBeginAllowThreads();
5575 result = wxGetDisplaySizeMM();
5576
5577 wxPyEndAllowThreads(__tstate);
5578 if (PyErr_Occurred()) SWIG_fail;
5579 }
5580 {
5581 wxSize * resultptr;
5582 resultptr = new wxSize((wxSize &)(result));
5583 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5584 }
5585 return resultobj;
5586 fail:
5587 return NULL;
5588 }
5589
5590
5591 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5592 PyObject *resultobj;
5593 int *arg1 = (int *) 0 ;
5594 int *arg2 = (int *) 0 ;
5595 int *arg3 = (int *) 0 ;
5596 int *arg4 = (int *) 0 ;
5597 int temp1 ;
5598 int res1 = 0 ;
5599 int temp2 ;
5600 int res2 = 0 ;
5601 int temp3 ;
5602 int res3 = 0 ;
5603 int temp4 ;
5604 int res4 = 0 ;
5605 char *kwnames[] = {
5606 NULL
5607 };
5608
5609 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5610 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5611 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5612 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5614 {
5615 if (!wxPyCheckForApp()) SWIG_fail;
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 Py_INCREF(Py_None); resultobj = Py_None;
5623 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5624 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5627 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5628 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5629 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5630 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj;
5639 wxRect result;
5640 char *kwnames[] = {
5641 NULL
5642 };
5643
5644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5645 {
5646 if (!wxPyCheckForApp()) SWIG_fail;
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 result = wxGetClientDisplayRect();
5649
5650 wxPyEndAllowThreads(__tstate);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 {
5654 wxRect * resultptr;
5655 resultptr = new wxRect((wxRect &)(result));
5656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5657 }
5658 return resultobj;
5659 fail:
5660 return NULL;
5661 }
5662
5663
5664 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj;
5666 wxCursor *arg1 = 0 ;
5667 PyObject * obj0 = 0 ;
5668 char *kwnames[] = {
5669 (char *) "cursor", NULL
5670 };
5671
5672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5673 {
5674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5675 if (SWIG_arg_fail(1)) SWIG_fail;
5676 if (arg1 == NULL) {
5677 SWIG_null_ref("wxCursor");
5678 }
5679 if (SWIG_arg_fail(1)) SWIG_fail;
5680 }
5681 {
5682 if (!wxPyCheckForApp()) SWIG_fail;
5683 PyThreadState* __tstate = wxPyBeginAllowThreads();
5684 wxSetCursor(*arg1);
5685
5686 wxPyEndAllowThreads(__tstate);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 Py_INCREF(Py_None); resultobj = Py_None;
5690 return resultobj;
5691 fail:
5692 return NULL;
5693 }
5694
5695
5696 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5697 PyObject *resultobj;
5698 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5699 PyObject * obj0 = 0 ;
5700 char *kwnames[] = {
5701 (char *) "cursor", NULL
5702 };
5703
5704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5705 if (obj0) {
5706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5707 if (SWIG_arg_fail(1)) SWIG_fail;
5708 }
5709 {
5710 if (!wxPyCheckForApp()) SWIG_fail;
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 wxBeginBusyCursor(arg1);
5713
5714 wxPyEndAllowThreads(__tstate);
5715 if (PyErr_Occurred()) SWIG_fail;
5716 }
5717 Py_INCREF(Py_None); resultobj = Py_None;
5718 return resultobj;
5719 fail:
5720 return NULL;
5721 }
5722
5723
5724 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5725 PyObject *resultobj;
5726 wxWindow *result;
5727 char *kwnames[] = {
5728 NULL
5729 };
5730
5731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5732 {
5733 if (!wxPyCheckForApp()) SWIG_fail;
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = (wxWindow *)wxGetActiveWindow();
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 {
5741 resultobj = wxPyMake_wxObject(result, 0);
5742 }
5743 return resultobj;
5744 fail:
5745 return NULL;
5746 }
5747
5748
5749 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5750 PyObject *resultobj;
5751 wxPoint *arg1 = 0 ;
5752 wxWindow *result;
5753 wxPoint temp1 ;
5754 PyObject * obj0 = 0 ;
5755 char *kwnames[] = {
5756 (char *) "pt", NULL
5757 };
5758
5759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5760 {
5761 arg1 = &temp1;
5762 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5763 }
5764 {
5765 if (!wxPyCheckForApp()) SWIG_fail;
5766 PyThreadState* __tstate = wxPyBeginAllowThreads();
5767 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5768
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 {
5773 resultobj = wxPyMake_wxObject(result, 0);
5774 }
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj;
5783 wxPoint *arg1 = 0 ;
5784 wxWindow *result;
5785 wxPoint temp1 ;
5786 PyObject * obj0 = 0 ;
5787 char *kwnames[] = {
5788 (char *) "pt", NULL
5789 };
5790
5791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5792 {
5793 arg1 = &temp1;
5794 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5795 }
5796 {
5797 if (!wxPyCheckForApp()) SWIG_fail;
5798 PyThreadState* __tstate = wxPyBeginAllowThreads();
5799 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5800
5801 wxPyEndAllowThreads(__tstate);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 {
5805 resultobj = wxPyMake_wxObject(result, 0);
5806 }
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj;
5815 wxWindow *arg1 = (wxWindow *) 0 ;
5816 wxWindow *result;
5817 PyObject * obj0 = 0 ;
5818 char *kwnames[] = {
5819 (char *) "win", NULL
5820 };
5821
5822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5824 if (SWIG_arg_fail(1)) SWIG_fail;
5825 {
5826 if (!wxPyCheckForApp()) SWIG_fail;
5827 PyThreadState* __tstate = wxPyBeginAllowThreads();
5828 result = (wxWindow *)wxGetTopLevelParent(arg1);
5829
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 {
5834 resultobj = wxPyMake_wxObject(result, 0);
5835 }
5836 return resultobj;
5837 fail:
5838 return NULL;
5839 }
5840
5841
5842 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5843 PyObject *resultobj;
5844 wxKeyCode arg1 ;
5845 bool result;
5846 PyObject * obj0 = 0 ;
5847 char *kwnames[] = {
5848 (char *) "key", NULL
5849 };
5850
5851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5852 {
5853 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5854 if (SWIG_arg_fail(1)) SWIG_fail;
5855 }
5856 {
5857 if (!wxPyCheckForApp()) SWIG_fail;
5858 PyThreadState* __tstate = wxPyBeginAllowThreads();
5859 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5860
5861 wxPyEndAllowThreads(__tstate);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 {
5865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5866 }
5867 return resultobj;
5868 fail:
5869 return NULL;
5870 }
5871
5872
5873 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5874 PyObject *resultobj;
5875 char *kwnames[] = {
5876 NULL
5877 };
5878
5879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5880 {
5881 if (!wxPyCheckForApp()) SWIG_fail;
5882 PyThreadState* __tstate = wxPyBeginAllowThreads();
5883 wxWakeUpMainThread();
5884
5885 wxPyEndAllowThreads(__tstate);
5886 if (PyErr_Occurred()) SWIG_fail;
5887 }
5888 Py_INCREF(Py_None); resultobj = Py_None;
5889 return resultobj;
5890 fail:
5891 return NULL;
5892 }
5893
5894
5895 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5896 PyObject *resultobj;
5897 char *kwnames[] = {
5898 NULL
5899 };
5900
5901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5902 {
5903 if (!wxPyCheckForApp()) SWIG_fail;
5904 PyThreadState* __tstate = wxPyBeginAllowThreads();
5905 wxMutexGuiEnter();
5906
5907 wxPyEndAllowThreads(__tstate);
5908 if (PyErr_Occurred()) SWIG_fail;
5909 }
5910 Py_INCREF(Py_None); resultobj = Py_None;
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj;
5919 char *kwnames[] = {
5920 NULL
5921 };
5922
5923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5924 {
5925 if (!wxPyCheckForApp()) SWIG_fail;
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 wxMutexGuiLeave();
5928
5929 wxPyEndAllowThreads(__tstate);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 Py_INCREF(Py_None); resultobj = Py_None;
5933 return resultobj;
5934 fail:
5935 return NULL;
5936 }
5937
5938
5939 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5940 PyObject *resultobj;
5941 wxMutexGuiLocker *result;
5942 char *kwnames[] = {
5943 NULL
5944 };
5945
5946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5947 {
5948 if (!wxPyCheckForApp()) SWIG_fail;
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5951
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5956 return resultobj;
5957 fail:
5958 return NULL;
5959 }
5960
5961
5962 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj;
5964 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5965 PyObject * obj0 = 0 ;
5966 char *kwnames[] = {
5967 (char *) "self", NULL
5968 };
5969
5970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5972 if (SWIG_arg_fail(1)) SWIG_fail;
5973 {
5974 PyThreadState* __tstate = wxPyBeginAllowThreads();
5975 delete arg1;
5976
5977 wxPyEndAllowThreads(__tstate);
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 Py_INCREF(Py_None); resultobj = Py_None;
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
5988 PyObject *obj;
5989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5990 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
5991 Py_INCREF(obj);
5992 return Py_BuildValue((char *)"");
5993 }
5994 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 bool result;
5997 char *kwnames[] = {
5998 NULL
5999 };
6000
6001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6002 {
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 result = (bool)wxThread_IsMain();
6005
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 {
6010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6011 }
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj;
6020 wxString *arg1 = 0 ;
6021 wxToolTip *result;
6022 bool temp1 = false ;
6023 PyObject * obj0 = 0 ;
6024 char *kwnames[] = {
6025 (char *) "tip", NULL
6026 };
6027
6028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6029 {
6030 arg1 = wxString_in_helper(obj0);
6031 if (arg1 == NULL) SWIG_fail;
6032 temp1 = true;
6033 }
6034 {
6035 if (!wxPyCheckForApp()) SWIG_fail;
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 {
6043 resultobj = wxPyMake_wxObject(result, 1);
6044 }
6045 {
6046 if (temp1)
6047 delete arg1;
6048 }
6049 return resultobj;
6050 fail:
6051 {
6052 if (temp1)
6053 delete arg1;
6054 }
6055 return NULL;
6056 }
6057
6058
6059 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6060 PyObject *resultobj;
6061 wxToolTip *arg1 = (wxToolTip *) 0 ;
6062 wxString *arg2 = 0 ;
6063 bool temp2 = false ;
6064 PyObject * obj0 = 0 ;
6065 PyObject * obj1 = 0 ;
6066 char *kwnames[] = {
6067 (char *) "self",(char *) "tip", NULL
6068 };
6069
6070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6072 if (SWIG_arg_fail(1)) SWIG_fail;
6073 {
6074 arg2 = wxString_in_helper(obj1);
6075 if (arg2 == NULL) SWIG_fail;
6076 temp2 = true;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 (arg1)->SetTip((wxString const &)*arg2);
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 Py_INCREF(Py_None); resultobj = Py_None;
6086 {
6087 if (temp2)
6088 delete arg2;
6089 }
6090 return resultobj;
6091 fail:
6092 {
6093 if (temp2)
6094 delete arg2;
6095 }
6096 return NULL;
6097 }
6098
6099
6100 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj;
6102 wxToolTip *arg1 = (wxToolTip *) 0 ;
6103 wxString result;
6104 PyObject * obj0 = 0 ;
6105 char *kwnames[] = {
6106 (char *) "self", NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6111 if (SWIG_arg_fail(1)) SWIG_fail;
6112 {
6113 PyThreadState* __tstate = wxPyBeginAllowThreads();
6114 result = (arg1)->GetTip();
6115
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 {
6120 #if wxUSE_UNICODE
6121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6122 #else
6123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6124 #endif
6125 }
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj;
6134 wxToolTip *arg1 = (wxToolTip *) 0 ;
6135 wxWindow *result;
6136 PyObject * obj0 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 {
6145 PyThreadState* __tstate = wxPyBeginAllowThreads();
6146 result = (wxWindow *)(arg1)->GetWindow();
6147
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 {
6152 resultobj = wxPyMake_wxObject(result, 0);
6153 }
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj;
6162 bool arg1 ;
6163 PyObject * obj0 = 0 ;
6164 char *kwnames[] = {
6165 (char *) "flag", NULL
6166 };
6167
6168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6169 {
6170 arg1 = (bool)(SWIG_As_bool(obj0));
6171 if (SWIG_arg_fail(1)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 wxToolTip::Enable(arg1);
6176
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 Py_INCREF(Py_None); resultobj = Py_None;
6181 return resultobj;
6182 fail:
6183 return NULL;
6184 }
6185
6186
6187 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj;
6189 long arg1 ;
6190 PyObject * obj0 = 0 ;
6191 char *kwnames[] = {
6192 (char *) "milliseconds", NULL
6193 };
6194
6195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6196 {
6197 arg1 = (long)(SWIG_As_long(obj0));
6198 if (SWIG_arg_fail(1)) SWIG_fail;
6199 }
6200 {
6201 PyThreadState* __tstate = wxPyBeginAllowThreads();
6202 wxToolTip::SetDelay(arg1);
6203
6204 wxPyEndAllowThreads(__tstate);
6205 if (PyErr_Occurred()) SWIG_fail;
6206 }
6207 Py_INCREF(Py_None); resultobj = Py_None;
6208 return resultobj;
6209 fail:
6210 return NULL;
6211 }
6212
6213
6214 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6215 PyObject *obj;
6216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6217 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6218 Py_INCREF(obj);
6219 return Py_BuildValue((char *)"");
6220 }
6221 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj;
6223 wxWindow *arg1 = (wxWindow *) 0 ;
6224 wxSize *arg2 = 0 ;
6225 wxCaret *result;
6226 wxSize temp2 ;
6227 PyObject * obj0 = 0 ;
6228 PyObject * obj1 = 0 ;
6229 char *kwnames[] = {
6230 (char *) "window",(char *) "size", NULL
6231 };
6232
6233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6235 if (SWIG_arg_fail(1)) SWIG_fail;
6236 {
6237 arg2 = &temp2;
6238 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6239 }
6240 {
6241 if (!wxPyCheckForApp()) SWIG_fail;
6242 PyThreadState* __tstate = wxPyBeginAllowThreads();
6243 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6244
6245 wxPyEndAllowThreads(__tstate);
6246 if (PyErr_Occurred()) SWIG_fail;
6247 }
6248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxCaret *arg1 = (wxCaret *) 0 ;
6258 PyObject * obj0 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 delete arg1;
6269
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 Py_INCREF(Py_None); resultobj = Py_None;
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
6280 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj;
6282 wxCaret *arg1 = (wxCaret *) 0 ;
6283 bool result;
6284 PyObject * obj0 = 0 ;
6285 char *kwnames[] = {
6286 (char *) "self", NULL
6287 };
6288
6289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6291 if (SWIG_arg_fail(1)) SWIG_fail;
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (bool)(arg1)->IsOk();
6295
6296 wxPyEndAllowThreads(__tstate);
6297 if (PyErr_Occurred()) SWIG_fail;
6298 }
6299 {
6300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6301 }
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 wxCaret *arg1 = (wxCaret *) 0 ;
6311 bool result;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "self", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (bool)(arg1)->IsVisible();
6323
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 {
6328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6329 }
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj;
6338 wxCaret *arg1 = (wxCaret *) 0 ;
6339 wxPoint result;
6340 PyObject * obj0 = 0 ;
6341 char *kwnames[] = {
6342 (char *) "self", NULL
6343 };
6344
6345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6347 if (SWIG_arg_fail(1)) SWIG_fail;
6348 {
6349 PyThreadState* __tstate = wxPyBeginAllowThreads();
6350 result = (arg1)->GetPosition();
6351
6352 wxPyEndAllowThreads(__tstate);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 {
6356 wxPoint * resultptr;
6357 resultptr = new wxPoint((wxPoint &)(result));
6358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6359 }
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj;
6368 wxCaret *arg1 = (wxCaret *) 0 ;
6369 int *arg2 = (int *) 0 ;
6370 int *arg3 = (int *) 0 ;
6371 int temp2 ;
6372 int res2 = 0 ;
6373 int temp3 ;
6374 int res3 = 0 ;
6375 PyObject * obj0 = 0 ;
6376 char *kwnames[] = {
6377 (char *) "self", NULL
6378 };
6379
6380 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6381 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6384 if (SWIG_arg_fail(1)) SWIG_fail;
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 (arg1)->GetPosition(arg2,arg3);
6388
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 Py_INCREF(Py_None); resultobj = Py_None;
6393 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6394 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6395 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6396 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 wxCaret *arg1 = (wxCaret *) 0 ;
6406 wxSize result;
6407 PyObject * obj0 = 0 ;
6408 char *kwnames[] = {
6409 (char *) "self", NULL
6410 };
6411
6412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6414 if (SWIG_arg_fail(1)) SWIG_fail;
6415 {
6416 PyThreadState* __tstate = wxPyBeginAllowThreads();
6417 result = (arg1)->GetSize();
6418
6419 wxPyEndAllowThreads(__tstate);
6420 if (PyErr_Occurred()) SWIG_fail;
6421 }
6422 {
6423 wxSize * resultptr;
6424 resultptr = new wxSize((wxSize &)(result));
6425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6426 }
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 wxCaret *arg1 = (wxCaret *) 0 ;
6436 int *arg2 = (int *) 0 ;
6437 int *arg3 = (int *) 0 ;
6438 int temp2 ;
6439 int res2 = 0 ;
6440 int temp3 ;
6441 int res3 = 0 ;
6442 PyObject * obj0 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self", NULL
6445 };
6446
6447 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6448 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6451 if (SWIG_arg_fail(1)) SWIG_fail;
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 (arg1)->GetSize(arg2,arg3);
6455
6456 wxPyEndAllowThreads(__tstate);
6457 if (PyErr_Occurred()) SWIG_fail;
6458 }
6459 Py_INCREF(Py_None); resultobj = Py_None;
6460 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6461 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6462 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6463 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6464 return resultobj;
6465 fail:
6466 return NULL;
6467 }
6468
6469
6470 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6471 PyObject *resultobj;
6472 wxCaret *arg1 = (wxCaret *) 0 ;
6473 wxWindow *result;
6474 PyObject * obj0 = 0 ;
6475 char *kwnames[] = {
6476 (char *) "self", NULL
6477 };
6478
6479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6481 if (SWIG_arg_fail(1)) SWIG_fail;
6482 {
6483 PyThreadState* __tstate = wxPyBeginAllowThreads();
6484 result = (wxWindow *)(arg1)->GetWindow();
6485
6486 wxPyEndAllowThreads(__tstate);
6487 if (PyErr_Occurred()) SWIG_fail;
6488 }
6489 {
6490 resultobj = wxPyMake_wxObject(result, 0);
6491 }
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj;
6500 wxCaret *arg1 = (wxCaret *) 0 ;
6501 int arg2 ;
6502 int arg3 ;
6503 PyObject * obj0 = 0 ;
6504 PyObject * obj1 = 0 ;
6505 PyObject * obj2 = 0 ;
6506 char *kwnames[] = {
6507 (char *) "self",(char *) "x",(char *) "y", NULL
6508 };
6509
6510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6512 if (SWIG_arg_fail(1)) SWIG_fail;
6513 {
6514 arg2 = (int)(SWIG_As_int(obj1));
6515 if (SWIG_arg_fail(2)) SWIG_fail;
6516 }
6517 {
6518 arg3 = (int)(SWIG_As_int(obj2));
6519 if (SWIG_arg_fail(3)) SWIG_fail;
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 (arg1)->Move(arg2,arg3);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 Py_INCREF(Py_None); resultobj = Py_None;
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxCaret *arg1 = (wxCaret *) 0 ;
6538 wxPoint *arg2 = 0 ;
6539 wxPoint temp2 ;
6540 PyObject * obj0 = 0 ;
6541 PyObject * obj1 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "self",(char *) "pt", NULL
6544 };
6545
6546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6548 if (SWIG_arg_fail(1)) SWIG_fail;
6549 {
6550 arg2 = &temp2;
6551 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6552 }
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 (arg1)->Move((wxPoint const &)*arg2);
6556
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 Py_INCREF(Py_None); resultobj = Py_None;
6561 return resultobj;
6562 fail:
6563 return NULL;
6564 }
6565
6566
6567 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6568 PyObject *resultobj;
6569 wxCaret *arg1 = (wxCaret *) 0 ;
6570 int arg2 ;
6571 int arg3 ;
6572 PyObject * obj0 = 0 ;
6573 PyObject * obj1 = 0 ;
6574 PyObject * obj2 = 0 ;
6575 char *kwnames[] = {
6576 (char *) "self",(char *) "width",(char *) "height", NULL
6577 };
6578
6579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6581 if (SWIG_arg_fail(1)) SWIG_fail;
6582 {
6583 arg2 = (int)(SWIG_As_int(obj1));
6584 if (SWIG_arg_fail(2)) SWIG_fail;
6585 }
6586 {
6587 arg3 = (int)(SWIG_As_int(obj2));
6588 if (SWIG_arg_fail(3)) SWIG_fail;
6589 }
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 (arg1)->SetSize(arg2,arg3);
6593
6594 wxPyEndAllowThreads(__tstate);
6595 if (PyErr_Occurred()) SWIG_fail;
6596 }
6597 Py_INCREF(Py_None); resultobj = Py_None;
6598 return resultobj;
6599 fail:
6600 return NULL;
6601 }
6602
6603
6604 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6605 PyObject *resultobj;
6606 wxCaret *arg1 = (wxCaret *) 0 ;
6607 wxSize *arg2 = 0 ;
6608 wxSize temp2 ;
6609 PyObject * obj0 = 0 ;
6610 PyObject * obj1 = 0 ;
6611 char *kwnames[] = {
6612 (char *) "self",(char *) "size", NULL
6613 };
6614
6615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6617 if (SWIG_arg_fail(1)) SWIG_fail;
6618 {
6619 arg2 = &temp2;
6620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6621 }
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 (arg1)->SetSize((wxSize const &)*arg2);
6625
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 Py_INCREF(Py_None); resultobj = Py_None;
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj;
6638 wxCaret *arg1 = (wxCaret *) 0 ;
6639 int arg2 = (int) true ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self",(char *) "show", NULL
6644 };
6645
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 if (obj1) {
6650 {
6651 arg2 = (int)(SWIG_As_int(obj1));
6652 if (SWIG_arg_fail(2)) SWIG_fail;
6653 }
6654 }
6655 {
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 (arg1)->Show(arg2);
6658
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 Py_INCREF(Py_None); resultobj = Py_None;
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6670 PyObject *resultobj;
6671 wxCaret *arg1 = (wxCaret *) 0 ;
6672 PyObject * obj0 = 0 ;
6673 char *kwnames[] = {
6674 (char *) "self", NULL
6675 };
6676
6677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6679 if (SWIG_arg_fail(1)) SWIG_fail;
6680 {
6681 PyThreadState* __tstate = wxPyBeginAllowThreads();
6682 (arg1)->Hide();
6683
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 Py_INCREF(Py_None); resultobj = Py_None;
6688 return resultobj;
6689 fail:
6690 return NULL;
6691 }
6692
6693
6694 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6695 PyObject *obj;
6696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6697 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6698 Py_INCREF(obj);
6699 return Py_BuildValue((char *)"");
6700 }
6701 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6702 PyObject *resultobj;
6703 int result;
6704 char *kwnames[] = {
6705 NULL
6706 };
6707
6708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 result = (int)wxCaret_GetBlinkTime();
6712
6713 wxPyEndAllowThreads(__tstate);
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 {
6717 resultobj = SWIG_From_int((int)(result));
6718 }
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6726 PyObject *resultobj;
6727 int arg1 ;
6728 PyObject * obj0 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "milliseconds", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6734 {
6735 arg1 = (int)(SWIG_As_int(obj0));
6736 if (SWIG_arg_fail(1)) SWIG_fail;
6737 }
6738 {
6739 PyThreadState* __tstate = wxPyBeginAllowThreads();
6740 wxCaret_SetBlinkTime(arg1);
6741
6742 wxPyEndAllowThreads(__tstate);
6743 if (PyErr_Occurred()) SWIG_fail;
6744 }
6745 Py_INCREF(Py_None); resultobj = Py_None;
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6753 PyObject *resultobj;
6754 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6755 wxBusyCursor *result;
6756 PyObject * obj0 = 0 ;
6757 char *kwnames[] = {
6758 (char *) "cursor", NULL
6759 };
6760
6761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6762 if (obj0) {
6763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6764 if (SWIG_arg_fail(1)) SWIG_fail;
6765 }
6766 {
6767 if (!wxPyCheckForApp()) SWIG_fail;
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6770
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj;
6783 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6784 PyObject * obj0 = 0 ;
6785 char *kwnames[] = {
6786 (char *) "self", NULL
6787 };
6788
6789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6791 if (SWIG_arg_fail(1)) SWIG_fail;
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 delete arg1;
6795
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 Py_INCREF(Py_None); resultobj = Py_None;
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6807 PyObject *obj;
6808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6809 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6810 Py_INCREF(obj);
6811 return Py_BuildValue((char *)"");
6812 }
6813 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxWindow *arg1 = (wxWindow *) NULL ;
6816 wxWindowDisabler *result;
6817 PyObject * obj0 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "winToSkip", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6823 if (obj0) {
6824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6825 if (SWIG_arg_fail(1)) SWIG_fail;
6826 }
6827 {
6828 if (!wxPyCheckForApp()) SWIG_fail;
6829 PyThreadState* __tstate = wxPyBeginAllowThreads();
6830 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6831
6832 wxPyEndAllowThreads(__tstate);
6833 if (PyErr_Occurred()) SWIG_fail;
6834 }
6835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6843 PyObject *resultobj;
6844 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6845 PyObject * obj0 = 0 ;
6846 char *kwnames[] = {
6847 (char *) "self", NULL
6848 };
6849
6850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6852 if (SWIG_arg_fail(1)) SWIG_fail;
6853 {
6854 PyThreadState* __tstate = wxPyBeginAllowThreads();
6855 delete arg1;
6856
6857 wxPyEndAllowThreads(__tstate);
6858 if (PyErr_Occurred()) SWIG_fail;
6859 }
6860 Py_INCREF(Py_None); resultobj = Py_None;
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6868 PyObject *obj;
6869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6870 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6871 Py_INCREF(obj);
6872 return Py_BuildValue((char *)"");
6873 }
6874 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxString *arg1 = 0 ;
6877 wxBusyInfo *result;
6878 bool temp1 = false ;
6879 PyObject * obj0 = 0 ;
6880 char *kwnames[] = {
6881 (char *) "message", NULL
6882 };
6883
6884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6885 {
6886 arg1 = wxString_in_helper(obj0);
6887 if (arg1 == NULL) SWIG_fail;
6888 temp1 = true;
6889 }
6890 {
6891 if (!wxPyCheckForApp()) SWIG_fail;
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6894
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6899 {
6900 if (temp1)
6901 delete arg1;
6902 }
6903 return resultobj;
6904 fail:
6905 {
6906 if (temp1)
6907 delete arg1;
6908 }
6909 return NULL;
6910 }
6911
6912
6913 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6914 PyObject *resultobj;
6915 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6916 PyObject * obj0 = 0 ;
6917 char *kwnames[] = {
6918 (char *) "self", NULL
6919 };
6920
6921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6923 if (SWIG_arg_fail(1)) SWIG_fail;
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 delete arg1;
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 Py_INCREF(Py_None); resultobj = Py_None;
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6939 PyObject *obj;
6940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6941 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6942 Py_INCREF(obj);
6943 return Py_BuildValue((char *)"");
6944 }
6945 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6946 PyObject *resultobj;
6947 wxStopWatch *result;
6948 char *kwnames[] = {
6949 NULL
6950 };
6951
6952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6953 {
6954 PyThreadState* __tstate = wxPyBeginAllowThreads();
6955 result = (wxStopWatch *)new wxStopWatch();
6956
6957 wxPyEndAllowThreads(__tstate);
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj;
6969 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6970 long arg2 = (long) 0 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "t0", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 if (obj1) {
6981 {
6982 arg2 = (long)(SWIG_As_long(obj1));
6983 if (SWIG_arg_fail(2)) SWIG_fail;
6984 }
6985 }
6986 {
6987 PyThreadState* __tstate = wxPyBeginAllowThreads();
6988 (arg1)->Start(arg2);
6989
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 Py_INCREF(Py_None); resultobj = Py_None;
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj;
7002 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7003 PyObject * obj0 = 0 ;
7004 char *kwnames[] = {
7005 (char *) "self", NULL
7006 };
7007
7008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7010 if (SWIG_arg_fail(1)) SWIG_fail;
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 (arg1)->Pause();
7014
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 Py_INCREF(Py_None); resultobj = Py_None;
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj;
7027 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7028 PyObject * obj0 = 0 ;
7029 char *kwnames[] = {
7030 (char *) "self", NULL
7031 };
7032
7033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7035 if (SWIG_arg_fail(1)) SWIG_fail;
7036 {
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 (arg1)->Resume();
7039
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 Py_INCREF(Py_None); resultobj = Py_None;
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj;
7052 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7053 long result;
7054 PyObject * obj0 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 result = (long)((wxStopWatch const *)arg1)->Time();
7065
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 {
7070 resultobj = SWIG_From_long((long)(result));
7071 }
7072 return resultobj;
7073 fail:
7074 return NULL;
7075 }
7076
7077
7078 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7079 PyObject *obj;
7080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7081 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7082 Py_INCREF(obj);
7083 return Py_BuildValue((char *)"");
7084 }
7085 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7086 PyObject *resultobj;
7087 int arg1 = (int) 9 ;
7088 int arg2 = (int) wxID_FILE1 ;
7089 wxFileHistory *result;
7090 PyObject * obj0 = 0 ;
7091 PyObject * obj1 = 0 ;
7092 char *kwnames[] = {
7093 (char *) "maxFiles",(char *) "idBase", NULL
7094 };
7095
7096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7097 if (obj0) {
7098 {
7099 arg1 = (int)(SWIG_As_int(obj0));
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 }
7102 }
7103 if (obj1) {
7104 {
7105 arg2 = (int)(SWIG_As_int(obj1));
7106 if (SWIG_arg_fail(2)) SWIG_fail;
7107 }
7108 }
7109 {
7110 PyThreadState* __tstate = wxPyBeginAllowThreads();
7111 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7112
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj;
7125 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7126 PyObject * obj0 = 0 ;
7127 char *kwnames[] = {
7128 (char *) "self", NULL
7129 };
7130
7131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7133 if (SWIG_arg_fail(1)) SWIG_fail;
7134 {
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 delete arg1;
7137
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 Py_INCREF(Py_None); resultobj = Py_None;
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj;
7150 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7151 wxString *arg2 = 0 ;
7152 bool temp2 = false ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char *kwnames[] = {
7156 (char *) "self",(char *) "file", NULL
7157 };
7158
7159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 {
7163 arg2 = wxString_in_helper(obj1);
7164 if (arg2 == NULL) SWIG_fail;
7165 temp2 = true;
7166 }
7167 {
7168 PyThreadState* __tstate = wxPyBeginAllowThreads();
7169 (arg1)->AddFileToHistory((wxString const &)*arg2);
7170
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 Py_INCREF(Py_None); resultobj = Py_None;
7175 {
7176 if (temp2)
7177 delete arg2;
7178 }
7179 return resultobj;
7180 fail:
7181 {
7182 if (temp2)
7183 delete arg2;
7184 }
7185 return NULL;
7186 }
7187
7188
7189 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7190 PyObject *resultobj;
7191 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7192 int arg2 ;
7193 PyObject * obj0 = 0 ;
7194 PyObject * obj1 = 0 ;
7195 char *kwnames[] = {
7196 (char *) "self",(char *) "i", NULL
7197 };
7198
7199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7201 if (SWIG_arg_fail(1)) SWIG_fail;
7202 {
7203 arg2 = (int)(SWIG_As_int(obj1));
7204 if (SWIG_arg_fail(2)) SWIG_fail;
7205 }
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 (arg1)->RemoveFileFromHistory(arg2);
7209
7210 wxPyEndAllowThreads(__tstate);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 Py_INCREF(Py_None); resultobj = Py_None;
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj;
7222 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7223 int result;
7224 PyObject * obj0 = 0 ;
7225 char *kwnames[] = {
7226 (char *) "self", NULL
7227 };
7228
7229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7231 if (SWIG_arg_fail(1)) SWIG_fail;
7232 {
7233 PyThreadState* __tstate = wxPyBeginAllowThreads();
7234 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7235
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 {
7240 resultobj = SWIG_From_int((int)(result));
7241 }
7242 return resultobj;
7243 fail:
7244 return NULL;
7245 }
7246
7247
7248 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7249 PyObject *resultobj;
7250 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7251 wxMenu *arg2 = (wxMenu *) 0 ;
7252 PyObject * obj0 = 0 ;
7253 PyObject * obj1 = 0 ;
7254 char *kwnames[] = {
7255 (char *) "self",(char *) "menu", NULL
7256 };
7257
7258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7260 if (SWIG_arg_fail(1)) SWIG_fail;
7261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7262 if (SWIG_arg_fail(2)) SWIG_fail;
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->UseMenu(arg2);
7266
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 Py_INCREF(Py_None); resultobj = Py_None;
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7280 wxMenu *arg2 = (wxMenu *) 0 ;
7281 PyObject * obj0 = 0 ;
7282 PyObject * obj1 = 0 ;
7283 char *kwnames[] = {
7284 (char *) "self",(char *) "menu", NULL
7285 };
7286
7287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7289 if (SWIG_arg_fail(1)) SWIG_fail;
7290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(2)) SWIG_fail;
7292 {
7293 PyThreadState* __tstate = wxPyBeginAllowThreads();
7294 (arg1)->RemoveMenu(arg2);
7295
7296 wxPyEndAllowThreads(__tstate);
7297 if (PyErr_Occurred()) SWIG_fail;
7298 }
7299 Py_INCREF(Py_None); resultobj = Py_None;
7300 return resultobj;
7301 fail:
7302 return NULL;
7303 }
7304
7305
7306 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7307 PyObject *resultobj;
7308 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7309 wxConfigBase *arg2 = 0 ;
7310 PyObject * obj0 = 0 ;
7311 PyObject * obj1 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "self",(char *) "config", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7318 if (SWIG_arg_fail(1)) SWIG_fail;
7319 {
7320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7321 if (SWIG_arg_fail(2)) SWIG_fail;
7322 if (arg2 == NULL) {
7323 SWIG_null_ref("wxConfigBase");
7324 }
7325 if (SWIG_arg_fail(2)) SWIG_fail;
7326 }
7327 {
7328 PyThreadState* __tstate = wxPyBeginAllowThreads();
7329 (arg1)->Load(*arg2);
7330
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 Py_INCREF(Py_None); resultobj = Py_None;
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj;
7343 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7344 wxConfigBase *arg2 = 0 ;
7345 PyObject * obj0 = 0 ;
7346 PyObject * obj1 = 0 ;
7347 char *kwnames[] = {
7348 (char *) "self",(char *) "config", NULL
7349 };
7350
7351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7353 if (SWIG_arg_fail(1)) SWIG_fail;
7354 {
7355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7356 if (SWIG_arg_fail(2)) SWIG_fail;
7357 if (arg2 == NULL) {
7358 SWIG_null_ref("wxConfigBase");
7359 }
7360 if (SWIG_arg_fail(2)) SWIG_fail;
7361 }
7362 {
7363 PyThreadState* __tstate = wxPyBeginAllowThreads();
7364 (arg1)->Save(*arg2);
7365
7366 wxPyEndAllowThreads(__tstate);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 Py_INCREF(Py_None); resultobj = Py_None;
7370 return resultobj;
7371 fail:
7372 return NULL;
7373 }
7374
7375
7376 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7377 PyObject *resultobj;
7378 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7379 PyObject * obj0 = 0 ;
7380 char *kwnames[] = {
7381 (char *) "self", NULL
7382 };
7383
7384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7386 if (SWIG_arg_fail(1)) SWIG_fail;
7387 {
7388 PyThreadState* __tstate = wxPyBeginAllowThreads();
7389 (arg1)->AddFilesToMenu();
7390
7391 wxPyEndAllowThreads(__tstate);
7392 if (PyErr_Occurred()) SWIG_fail;
7393 }
7394 Py_INCREF(Py_None); resultobj = Py_None;
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
7401 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7402 PyObject *resultobj;
7403 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7404 wxMenu *arg2 = (wxMenu *) 0 ;
7405 PyObject * obj0 = 0 ;
7406 PyObject * obj1 = 0 ;
7407 char *kwnames[] = {
7408 (char *) "self",(char *) "menu", NULL
7409 };
7410
7411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(1)) SWIG_fail;
7414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7415 if (SWIG_arg_fail(2)) SWIG_fail;
7416 {
7417 PyThreadState* __tstate = wxPyBeginAllowThreads();
7418 (arg1)->AddFilesToMenu(arg2);
7419
7420 wxPyEndAllowThreads(__tstate);
7421 if (PyErr_Occurred()) SWIG_fail;
7422 }
7423 Py_INCREF(Py_None); resultobj = Py_None;
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7431 PyObject *resultobj;
7432 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7433 int arg2 ;
7434 wxString result;
7435 PyObject * obj0 = 0 ;
7436 PyObject * obj1 = 0 ;
7437 char *kwnames[] = {
7438 (char *) "self",(char *) "i", NULL
7439 };
7440
7441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7443 if (SWIG_arg_fail(1)) SWIG_fail;
7444 {
7445 arg2 = (int)(SWIG_As_int(obj1));
7446 if (SWIG_arg_fail(2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 #if wxUSE_UNICODE
7457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7458 #else
7459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7460 #endif
7461 }
7462 return resultobj;
7463 fail:
7464 return NULL;
7465 }
7466
7467
7468 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7469 PyObject *resultobj;
7470 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7471 int result;
7472 PyObject * obj0 = 0 ;
7473 char *kwnames[] = {
7474 (char *) "self", NULL
7475 };
7476
7477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7479 if (SWIG_arg_fail(1)) SWIG_fail;
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 result = (int)((wxFileHistory const *)arg1)->GetCount();
7483
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 {
7488 resultobj = SWIG_From_int((int)(result));
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7497 PyObject *obj;
7498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7499 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7500 Py_INCREF(obj);
7501 return Py_BuildValue((char *)"");
7502 }
7503 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj;
7505 wxString *arg1 = 0 ;
7506 wxString const &arg2_defvalue = wxPyEmptyString ;
7507 wxString *arg2 = (wxString *) &arg2_defvalue ;
7508 wxSingleInstanceChecker *result;
7509 bool temp1 = false ;
7510 bool temp2 = false ;
7511 PyObject * obj0 = 0 ;
7512 PyObject * obj1 = 0 ;
7513 char *kwnames[] = {
7514 (char *) "name",(char *) "path", NULL
7515 };
7516
7517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7518 {
7519 arg1 = wxString_in_helper(obj0);
7520 if (arg1 == NULL) SWIG_fail;
7521 temp1 = true;
7522 }
7523 if (obj1) {
7524 {
7525 arg2 = wxString_in_helper(obj1);
7526 if (arg2 == NULL) SWIG_fail;
7527 temp2 = true;
7528 }
7529 }
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7533
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7538 {
7539 if (temp1)
7540 delete arg1;
7541 }
7542 {
7543 if (temp2)
7544 delete arg2;
7545 }
7546 return resultobj;
7547 fail:
7548 {
7549 if (temp1)
7550 delete arg1;
7551 }
7552 {
7553 if (temp2)
7554 delete arg2;
7555 }
7556 return NULL;
7557 }
7558
7559
7560 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7561 PyObject *resultobj;
7562 wxSingleInstanceChecker *result;
7563 char *kwnames[] = {
7564 NULL
7565 };
7566
7567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7571
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj;
7584 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7585 PyObject * obj0 = 0 ;
7586 char *kwnames[] = {
7587 (char *) "self", NULL
7588 };
7589
7590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7592 if (SWIG_arg_fail(1)) SWIG_fail;
7593 {
7594 PyThreadState* __tstate = wxPyBeginAllowThreads();
7595 delete arg1;
7596
7597 wxPyEndAllowThreads(__tstate);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 Py_INCREF(Py_None); resultobj = Py_None;
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj;
7609 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7610 wxString *arg2 = 0 ;
7611 wxString const &arg3_defvalue = wxPyEmptyString ;
7612 wxString *arg3 = (wxString *) &arg3_defvalue ;
7613 bool result;
7614 bool temp2 = false ;
7615 bool temp3 = false ;
7616 PyObject * obj0 = 0 ;
7617 PyObject * obj1 = 0 ;
7618 PyObject * obj2 = 0 ;
7619 char *kwnames[] = {
7620 (char *) "self",(char *) "name",(char *) "path", NULL
7621 };
7622
7623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7625 if (SWIG_arg_fail(1)) SWIG_fail;
7626 {
7627 arg2 = wxString_in_helper(obj1);
7628 if (arg2 == NULL) SWIG_fail;
7629 temp2 = true;
7630 }
7631 if (obj2) {
7632 {
7633 arg3 = wxString_in_helper(obj2);
7634 if (arg3 == NULL) SWIG_fail;
7635 temp3 = true;
7636 }
7637 }
7638 {
7639 PyThreadState* __tstate = wxPyBeginAllowThreads();
7640 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7641
7642 wxPyEndAllowThreads(__tstate);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 {
7646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7647 }
7648 {
7649 if (temp2)
7650 delete arg2;
7651 }
7652 {
7653 if (temp3)
7654 delete arg3;
7655 }
7656 return resultobj;
7657 fail:
7658 {
7659 if (temp2)
7660 delete arg2;
7661 }
7662 {
7663 if (temp3)
7664 delete arg3;
7665 }
7666 return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj;
7672 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7673 bool result;
7674 PyObject * obj0 = 0 ;
7675 char *kwnames[] = {
7676 (char *) "self", NULL
7677 };
7678
7679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7681 if (SWIG_arg_fail(1)) SWIG_fail;
7682 {
7683 PyThreadState* __tstate = wxPyBeginAllowThreads();
7684 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7685
7686 wxPyEndAllowThreads(__tstate);
7687 if (PyErr_Occurred()) SWIG_fail;
7688 }
7689 {
7690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7691 }
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7699 PyObject *obj;
7700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7701 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7702 Py_INCREF(obj);
7703 return Py_BuildValue((char *)"");
7704 }
7705 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj;
7707 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 delete arg1;
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 Py_INCREF(Py_None); resultobj = Py_None;
7724 return resultobj;
7725 fail:
7726 return NULL;
7727 }
7728
7729
7730 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7731 PyObject *resultobj;
7732 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7733 wxString result;
7734 PyObject * obj0 = 0 ;
7735 char *kwnames[] = {
7736 (char *) "self", NULL
7737 };
7738
7739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7741 if (SWIG_arg_fail(1)) SWIG_fail;
7742 {
7743 PyThreadState* __tstate = wxPyBeginAllowThreads();
7744 result = (arg1)->GetTip();
7745
7746 wxPyEndAllowThreads(__tstate);
7747 if (PyErr_Occurred()) SWIG_fail;
7748 }
7749 {
7750 #if wxUSE_UNICODE
7751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7752 #else
7753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7754 #endif
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7765 size_t result;
7766 PyObject * obj0 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (size_t)(arg1)->GetCurrentTip();
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7783 }
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7793 wxString *arg2 = 0 ;
7794 wxString result;
7795 bool temp2 = false ;
7796 PyObject * obj0 = 0 ;
7797 PyObject * obj1 = 0 ;
7798 char *kwnames[] = {
7799 (char *) "self",(char *) "tip", NULL
7800 };
7801
7802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7804 if (SWIG_arg_fail(1)) SWIG_fail;
7805 {
7806 arg2 = wxString_in_helper(obj1);
7807 if (arg2 == NULL) SWIG_fail;
7808 temp2 = true;
7809 }
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7813
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 {
7818 #if wxUSE_UNICODE
7819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7820 #else
7821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7822 #endif
7823 }
7824 {
7825 if (temp2)
7826 delete arg2;
7827 }
7828 return resultobj;
7829 fail:
7830 {
7831 if (temp2)
7832 delete arg2;
7833 }
7834 return NULL;
7835 }
7836
7837
7838 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7839 PyObject *obj;
7840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7841 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7842 Py_INCREF(obj);
7843 return Py_BuildValue((char *)"");
7844 }
7845 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj;
7847 size_t arg1 ;
7848 wxPyTipProvider *result;
7849 PyObject * obj0 = 0 ;
7850 char *kwnames[] = {
7851 (char *) "currentTip", NULL
7852 };
7853
7854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7855 {
7856 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 }
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7862
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj;
7875 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7876 PyObject *arg2 = (PyObject *) 0 ;
7877 PyObject *arg3 = (PyObject *) 0 ;
7878 PyObject * obj0 = 0 ;
7879 PyObject * obj1 = 0 ;
7880 PyObject * obj2 = 0 ;
7881 char *kwnames[] = {
7882 (char *) "self",(char *) "self",(char *) "_class", NULL
7883 };
7884
7885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7887 if (SWIG_arg_fail(1)) SWIG_fail;
7888 arg2 = obj1;
7889 arg3 = obj2;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 (arg1)->_setCallbackInfo(arg2,arg3);
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 Py_INCREF(Py_None); resultobj = Py_None;
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7905 PyObject *obj;
7906 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7907 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7908 Py_INCREF(obj);
7909 return Py_BuildValue((char *)"");
7910 }
7911 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj;
7913 wxWindow *arg1 = (wxWindow *) 0 ;
7914 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7915 bool arg3 = (bool) true ;
7916 bool result;
7917 PyObject * obj0 = 0 ;
7918 PyObject * obj1 = 0 ;
7919 PyObject * obj2 = 0 ;
7920 char *kwnames[] = {
7921 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7922 };
7923
7924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7926 if (SWIG_arg_fail(1)) SWIG_fail;
7927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7928 if (SWIG_arg_fail(2)) SWIG_fail;
7929 if (obj2) {
7930 {
7931 arg3 = (bool)(SWIG_As_bool(obj2));
7932 if (SWIG_arg_fail(3)) SWIG_fail;
7933 }
7934 }
7935 {
7936 if (!wxPyCheckForApp()) SWIG_fail;
7937 PyThreadState* __tstate = wxPyBeginAllowThreads();
7938 result = (bool)wxShowTip(arg1,arg2,arg3);
7939
7940 wxPyEndAllowThreads(__tstate);
7941 if (PyErr_Occurred()) SWIG_fail;
7942 }
7943 {
7944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7945 }
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxString *arg1 = 0 ;
7955 size_t arg2 ;
7956 wxTipProvider *result;
7957 bool temp1 = false ;
7958 PyObject * obj0 = 0 ;
7959 PyObject * obj1 = 0 ;
7960 char *kwnames[] = {
7961 (char *) "filename",(char *) "currentTip", NULL
7962 };
7963
7964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7965 {
7966 arg1 = wxString_in_helper(obj0);
7967 if (arg1 == NULL) SWIG_fail;
7968 temp1 = true;
7969 }
7970 {
7971 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7972 if (SWIG_arg_fail(2)) SWIG_fail;
7973 }
7974 {
7975 if (!wxPyCheckForApp()) SWIG_fail;
7976 PyThreadState* __tstate = wxPyBeginAllowThreads();
7977 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7978
7979 wxPyEndAllowThreads(__tstate);
7980 if (PyErr_Occurred()) SWIG_fail;
7981 }
7982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7983 {
7984 if (temp1)
7985 delete arg1;
7986 }
7987 return resultobj;
7988 fail:
7989 {
7990 if (temp1)
7991 delete arg1;
7992 }
7993 return NULL;
7994 }
7995
7996
7997 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
7998 PyObject *resultobj;
7999 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8000 int arg2 = (int) -1 ;
8001 wxPyTimer *result;
8002 PyObject * obj0 = 0 ;
8003 PyObject * obj1 = 0 ;
8004 char *kwnames[] = {
8005 (char *) "owner",(char *) "id", NULL
8006 };
8007
8008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8009 if (obj0) {
8010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8011 if (SWIG_arg_fail(1)) SWIG_fail;
8012 }
8013 if (obj1) {
8014 {
8015 arg2 = (int)(SWIG_As_int(obj1));
8016 if (SWIG_arg_fail(2)) SWIG_fail;
8017 }
8018 }
8019 {
8020 if (!wxPyCheckForApp()) SWIG_fail;
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8023
8024 wxPyEndAllowThreads(__tstate);
8025 if (PyErr_Occurred()) SWIG_fail;
8026 }
8027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8028 return resultobj;
8029 fail:
8030 return NULL;
8031 }
8032
8033
8034 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8035 PyObject *resultobj;
8036 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8037 PyObject * obj0 = 0 ;
8038 char *kwnames[] = {
8039 (char *) "self", NULL
8040 };
8041
8042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8044 if (SWIG_arg_fail(1)) SWIG_fail;
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 delete arg1;
8048
8049 wxPyEndAllowThreads(__tstate);
8050 if (PyErr_Occurred()) SWIG_fail;
8051 }
8052 Py_INCREF(Py_None); resultobj = Py_None;
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj;
8061 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8062 PyObject *arg2 = (PyObject *) 0 ;
8063 PyObject *arg3 = (PyObject *) 0 ;
8064 int arg4 = (int) 1 ;
8065 PyObject * obj0 = 0 ;
8066 PyObject * obj1 = 0 ;
8067 PyObject * obj2 = 0 ;
8068 PyObject * obj3 = 0 ;
8069 char *kwnames[] = {
8070 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8071 };
8072
8073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8075 if (SWIG_arg_fail(1)) SWIG_fail;
8076 arg2 = obj1;
8077 arg3 = obj2;
8078 if (obj3) {
8079 {
8080 arg4 = (int)(SWIG_As_int(obj3));
8081 if (SWIG_arg_fail(4)) SWIG_fail;
8082 }
8083 }
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8087
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 Py_INCREF(Py_None); resultobj = Py_None;
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8099 PyObject *resultobj;
8100 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8101 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8102 int arg3 = (int) -1 ;
8103 PyObject * obj0 = 0 ;
8104 PyObject * obj1 = 0 ;
8105 PyObject * obj2 = 0 ;
8106 char *kwnames[] = {
8107 (char *) "self",(char *) "owner",(char *) "id", NULL
8108 };
8109
8110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8112 if (SWIG_arg_fail(1)) SWIG_fail;
8113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8114 if (SWIG_arg_fail(2)) SWIG_fail;
8115 if (obj2) {
8116 {
8117 arg3 = (int)(SWIG_As_int(obj2));
8118 if (SWIG_arg_fail(3)) SWIG_fail;
8119 }
8120 }
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 (arg1)->SetOwner(arg2,arg3);
8124
8125 wxPyEndAllowThreads(__tstate);
8126 if (PyErr_Occurred()) SWIG_fail;
8127 }
8128 Py_INCREF(Py_None); resultobj = Py_None;
8129 return resultobj;
8130 fail:
8131 return NULL;
8132 }
8133
8134
8135 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8136 PyObject *resultobj;
8137 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8138 wxEvtHandler *result;
8139 PyObject * obj0 = 0 ;
8140 char *kwnames[] = {
8141 (char *) "self", NULL
8142 };
8143
8144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8146 if (SWIG_arg_fail(1)) SWIG_fail;
8147 {
8148 PyThreadState* __tstate = wxPyBeginAllowThreads();
8149 result = (wxEvtHandler *)(arg1)->GetOwner();
8150
8151 wxPyEndAllowThreads(__tstate);
8152 if (PyErr_Occurred()) SWIG_fail;
8153 }
8154 {
8155 resultobj = wxPyMake_wxObject(result, 0);
8156 }
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8166 int arg2 = (int) -1 ;
8167 bool arg3 = (bool) false ;
8168 bool result;
8169 PyObject * obj0 = 0 ;
8170 PyObject * obj1 = 0 ;
8171 PyObject * obj2 = 0 ;
8172 char *kwnames[] = {
8173 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8174 };
8175
8176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8178 if (SWIG_arg_fail(1)) SWIG_fail;
8179 if (obj1) {
8180 {
8181 arg2 = (int)(SWIG_As_int(obj1));
8182 if (SWIG_arg_fail(2)) SWIG_fail;
8183 }
8184 }
8185 if (obj2) {
8186 {
8187 arg3 = (bool)(SWIG_As_bool(obj2));
8188 if (SWIG_arg_fail(3)) SWIG_fail;
8189 }
8190 }
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 result = (bool)(arg1)->Start(arg2,arg3);
8194
8195 wxPyEndAllowThreads(__tstate);
8196 if (PyErr_Occurred()) SWIG_fail;
8197 }
8198 {
8199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8210 PyObject * obj0 = 0 ;
8211 char *kwnames[] = {
8212 (char *) "self", NULL
8213 };
8214
8215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8217 if (SWIG_arg_fail(1)) SWIG_fail;
8218 {
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 (arg1)->Stop();
8221
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 Py_INCREF(Py_None); resultobj = Py_None;
8226 return resultobj;
8227 fail:
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj;
8234 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8235 bool result;
8236 PyObject * obj0 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 {
8252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8253 }
8254 return resultobj;
8255 fail:
8256 return NULL;
8257 }
8258
8259
8260 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8261 PyObject *resultobj;
8262 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8263 int result;
8264 PyObject * obj0 = 0 ;
8265 char *kwnames[] = {
8266 (char *) "self", NULL
8267 };
8268
8269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8271 if (SWIG_arg_fail(1)) SWIG_fail;
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8275
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 {
8280 resultobj = SWIG_From_int((int)(result));
8281 }
8282 return resultobj;
8283 fail:
8284 return NULL;
8285 }
8286
8287
8288 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8289 PyObject *resultobj;
8290 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8291 bool result;
8292 PyObject * obj0 = 0 ;
8293 char *kwnames[] = {
8294 (char *) "self", NULL
8295 };
8296
8297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8299 if (SWIG_arg_fail(1)) SWIG_fail;
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8303
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 {
8308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8309 }
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj;
8318 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8319 int result;
8320 PyObject * obj0 = 0 ;
8321 char *kwnames[] = {
8322 (char *) "self", NULL
8323 };
8324
8325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8327 if (SWIG_arg_fail(1)) SWIG_fail;
8328 {
8329 PyThreadState* __tstate = wxPyBeginAllowThreads();
8330 result = (int)((wxPyTimer const *)arg1)->GetId();
8331
8332 wxPyEndAllowThreads(__tstate);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 {
8336 resultobj = SWIG_From_int((int)(result));
8337 }
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8345 PyObject *obj;
8346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8347 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8348 Py_INCREF(obj);
8349 return Py_BuildValue((char *)"");
8350 }
8351 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8352 PyObject *resultobj;
8353 int arg1 = (int) 0 ;
8354 int arg2 = (int) 0 ;
8355 wxTimerEvent *result;
8356 PyObject * obj0 = 0 ;
8357 PyObject * obj1 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "timerid",(char *) "interval", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8363 if (obj0) {
8364 {
8365 arg1 = (int)(SWIG_As_int(obj0));
8366 if (SWIG_arg_fail(1)) SWIG_fail;
8367 }
8368 }
8369 if (obj1) {
8370 {
8371 arg2 = (int)(SWIG_As_int(obj1));
8372 if (SWIG_arg_fail(2)) SWIG_fail;
8373 }
8374 }
8375 {
8376 PyThreadState* __tstate = wxPyBeginAllowThreads();
8377 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8378
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj;
8391 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8392 int result;
8393 PyObject * obj0 = 0 ;
8394 char *kwnames[] = {
8395 (char *) "self", NULL
8396 };
8397
8398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8400 if (SWIG_arg_fail(1)) SWIG_fail;
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8404
8405 wxPyEndAllowThreads(__tstate);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 {
8409 resultobj = SWIG_From_int((int)(result));
8410 }
8411 return resultobj;
8412 fail:
8413 return NULL;
8414 }
8415
8416
8417 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8418 PyObject *obj;
8419 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8420 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8421 Py_INCREF(obj);
8422 return Py_BuildValue((char *)"");
8423 }
8424 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8425 PyObject *resultobj;
8426 wxTimer *arg1 = 0 ;
8427 wxTimerRunner *result;
8428 PyObject * obj0 = 0 ;
8429
8430 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8431 {
8432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8433 if (SWIG_arg_fail(1)) SWIG_fail;
8434 if (arg1 == NULL) {
8435 SWIG_null_ref("wxTimer");
8436 }
8437 if (SWIG_arg_fail(1)) SWIG_fail;
8438 }
8439 {
8440 if (!wxPyCheckForApp()) SWIG_fail;
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8455 PyObject *resultobj;
8456 wxTimer *arg1 = 0 ;
8457 int arg2 ;
8458 bool arg3 = (bool) false ;
8459 wxTimerRunner *result;
8460 PyObject * obj0 = 0 ;
8461 PyObject * obj1 = 0 ;
8462 PyObject * obj2 = 0 ;
8463
8464 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8465 {
8466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8467 if (SWIG_arg_fail(1)) SWIG_fail;
8468 if (arg1 == NULL) {
8469 SWIG_null_ref("wxTimer");
8470 }
8471 if (SWIG_arg_fail(1)) SWIG_fail;
8472 }
8473 {
8474 arg2 = (int)(SWIG_As_int(obj1));
8475 if (SWIG_arg_fail(2)) SWIG_fail;
8476 }
8477 if (obj2) {
8478 {
8479 arg3 = (bool)(SWIG_As_bool(obj2));
8480 if (SWIG_arg_fail(3)) SWIG_fail;
8481 }
8482 }
8483 {
8484 if (!wxPyCheckForApp()) SWIG_fail;
8485 PyThreadState* __tstate = wxPyBeginAllowThreads();
8486 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8487
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8499 int argc;
8500 PyObject *argv[4];
8501 int ii;
8502
8503 argc = PyObject_Length(args);
8504 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8505 argv[ii] = PyTuple_GetItem(args,ii);
8506 }
8507 if (argc == 1) {
8508 int _v;
8509 {
8510 void *ptr = 0;
8511 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8512 _v = 0;
8513 PyErr_Clear();
8514 } else {
8515 _v = (ptr != 0);
8516 }
8517 }
8518 if (_v) {
8519 return _wrap_new_TimerRunner__SWIG_0(self,args);
8520 }
8521 }
8522 if ((argc >= 2) && (argc <= 3)) {
8523 int _v;
8524 {
8525 void *ptr = 0;
8526 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8527 _v = 0;
8528 PyErr_Clear();
8529 } else {
8530 _v = (ptr != 0);
8531 }
8532 }
8533 if (_v) {
8534 _v = SWIG_Check_int(argv[1]);
8535 if (_v) {
8536 if (argc <= 2) {
8537 return _wrap_new_TimerRunner__SWIG_1(self,args);
8538 }
8539 _v = SWIG_Check_bool(argv[2]);
8540 if (_v) {
8541 return _wrap_new_TimerRunner__SWIG_1(self,args);
8542 }
8543 }
8544 }
8545 }
8546
8547 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8548 return NULL;
8549 }
8550
8551
8552 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8553 PyObject *resultobj;
8554 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8555 PyObject * obj0 = 0 ;
8556 char *kwnames[] = {
8557 (char *) "self", NULL
8558 };
8559
8560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8562 if (SWIG_arg_fail(1)) SWIG_fail;
8563 {
8564 PyThreadState* __tstate = wxPyBeginAllowThreads();
8565 delete arg1;
8566
8567 wxPyEndAllowThreads(__tstate);
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 Py_INCREF(Py_None); resultobj = Py_None;
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj;
8579 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8580 int arg2 ;
8581 bool arg3 = (bool) false ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 PyObject * obj2 = 0 ;
8585 char *kwnames[] = {
8586 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8587 };
8588
8589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8591 if (SWIG_arg_fail(1)) SWIG_fail;
8592 {
8593 arg2 = (int)(SWIG_As_int(obj1));
8594 if (SWIG_arg_fail(2)) SWIG_fail;
8595 }
8596 if (obj2) {
8597 {
8598 arg3 = (bool)(SWIG_As_bool(obj2));
8599 if (SWIG_arg_fail(3)) SWIG_fail;
8600 }
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 (arg1)->Start(arg2,arg3);
8605
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 Py_INCREF(Py_None); resultobj = Py_None;
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8617 PyObject *obj;
8618 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8619 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8620 Py_INCREF(obj);
8621 return Py_BuildValue((char *)"");
8622 }
8623 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8624 PyObject *resultobj;
8625 wxLog *result;
8626 char *kwnames[] = {
8627 NULL
8628 };
8629
8630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8631 {
8632 PyThreadState* __tstate = wxPyBeginAllowThreads();
8633 result = (wxLog *)new wxLog();
8634
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj;
8647 bool result;
8648 char *kwnames[] = {
8649 NULL
8650 };
8651
8652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8653 {
8654 PyThreadState* __tstate = wxPyBeginAllowThreads();
8655 result = (bool)wxLog::IsEnabled();
8656
8657 wxPyEndAllowThreads(__tstate);
8658 if (PyErr_Occurred()) SWIG_fail;
8659 }
8660 {
8661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8662 }
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8670 PyObject *resultobj;
8671 bool arg1 = (bool) true ;
8672 bool result;
8673 PyObject * obj0 = 0 ;
8674 char *kwnames[] = {
8675 (char *) "doIt", NULL
8676 };
8677
8678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8679 if (obj0) {
8680 {
8681 arg1 = (bool)(SWIG_As_bool(obj0));
8682 if (SWIG_arg_fail(1)) SWIG_fail;
8683 }
8684 }
8685 {
8686 PyThreadState* __tstate = wxPyBeginAllowThreads();
8687 result = (bool)wxLog::EnableLogging(arg1);
8688
8689 wxPyEndAllowThreads(__tstate);
8690 if (PyErr_Occurred()) SWIG_fail;
8691 }
8692 {
8693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8694 }
8695 return resultobj;
8696 fail:
8697 return NULL;
8698 }
8699
8700
8701 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8702 PyObject *resultobj;
8703 wxLogLevel arg1 ;
8704 wxChar *arg2 = (wxChar *) 0 ;
8705 time_t arg3 ;
8706 PyObject * obj0 = 0 ;
8707 PyObject * obj1 = 0 ;
8708 PyObject * obj2 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "level",(char *) "szString",(char *) "t", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8714 {
8715 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8716 if (SWIG_arg_fail(1)) SWIG_fail;
8717 }
8718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8719 if (SWIG_arg_fail(2)) SWIG_fail;
8720 {
8721 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8722 if (SWIG_arg_fail(3)) SWIG_fail;
8723 }
8724 {
8725 PyThreadState* __tstate = wxPyBeginAllowThreads();
8726 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8727
8728 wxPyEndAllowThreads(__tstate);
8729 if (PyErr_Occurred()) SWIG_fail;
8730 }
8731 Py_INCREF(Py_None); resultobj = Py_None;
8732 return resultobj;
8733 fail:
8734 return NULL;
8735 }
8736
8737
8738 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8739 PyObject *resultobj;
8740 wxLog *arg1 = (wxLog *) 0 ;
8741 PyObject * obj0 = 0 ;
8742 char *kwnames[] = {
8743 (char *) "self", NULL
8744 };
8745
8746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8748 if (SWIG_arg_fail(1)) SWIG_fail;
8749 {
8750 PyThreadState* __tstate = wxPyBeginAllowThreads();
8751 (arg1)->Flush();
8752
8753 wxPyEndAllowThreads(__tstate);
8754 if (PyErr_Occurred()) SWIG_fail;
8755 }
8756 Py_INCREF(Py_None); resultobj = Py_None;
8757 return resultobj;
8758 fail:
8759 return NULL;
8760 }
8761
8762
8763 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8764 PyObject *resultobj;
8765 char *kwnames[] = {
8766 NULL
8767 };
8768
8769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 wxLog::FlushActive();
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 Py_INCREF(Py_None); resultobj = Py_None;
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj;
8786 wxLog *result;
8787 char *kwnames[] = {
8788 NULL
8789 };
8790
8791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8792 {
8793 PyThreadState* __tstate = wxPyBeginAllowThreads();
8794 result = (wxLog *)wxLog::GetActiveTarget();
8795
8796 wxPyEndAllowThreads(__tstate);
8797 if (PyErr_Occurred()) SWIG_fail;
8798 }
8799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8800 return resultobj;
8801 fail:
8802 return NULL;
8803 }
8804
8805
8806 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8807 PyObject *resultobj;
8808 wxLog *arg1 = (wxLog *) 0 ;
8809 wxLog *result;
8810 PyObject * obj0 = 0 ;
8811 char *kwnames[] = {
8812 (char *) "pLogger", NULL
8813 };
8814
8815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8817 if (SWIG_arg_fail(1)) SWIG_fail;
8818 {
8819 PyThreadState* __tstate = wxPyBeginAllowThreads();
8820 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8821
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj;
8834 char *kwnames[] = {
8835 NULL
8836 };
8837
8838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8839 {
8840 PyThreadState* __tstate = wxPyBeginAllowThreads();
8841 wxLog::Suspend();
8842
8843 wxPyEndAllowThreads(__tstate);
8844 if (PyErr_Occurred()) SWIG_fail;
8845 }
8846 Py_INCREF(Py_None); resultobj = Py_None;
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8854 PyObject *resultobj;
8855 char *kwnames[] = {
8856 NULL
8857 };
8858
8859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 wxLog::Resume();
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 Py_INCREF(Py_None); resultobj = Py_None;
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 bool arg1 = (bool) true ;
8877 PyObject * obj0 = 0 ;
8878 char *kwnames[] = {
8879 (char *) "bVerbose", NULL
8880 };
8881
8882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8883 if (obj0) {
8884 {
8885 arg1 = (bool)(SWIG_As_bool(obj0));
8886 if (SWIG_arg_fail(1)) SWIG_fail;
8887 }
8888 }
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 wxLog::SetVerbose(arg1);
8892
8893 wxPyEndAllowThreads(__tstate);
8894 if (PyErr_Occurred()) SWIG_fail;
8895 }
8896 Py_INCREF(Py_None); resultobj = Py_None;
8897 return resultobj;
8898 fail:
8899 return NULL;
8900 }
8901
8902
8903 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8904 PyObject *resultobj;
8905 wxLogLevel arg1 ;
8906 PyObject * obj0 = 0 ;
8907 char *kwnames[] = {
8908 (char *) "logLevel", NULL
8909 };
8910
8911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8912 {
8913 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8914 if (SWIG_arg_fail(1)) SWIG_fail;
8915 }
8916 {
8917 PyThreadState* __tstate = wxPyBeginAllowThreads();
8918 wxLog::SetLogLevel(arg1);
8919
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 Py_INCREF(Py_None); resultobj = Py_None;
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj;
8932 char *kwnames[] = {
8933 NULL
8934 };
8935
8936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8937 {
8938 PyThreadState* __tstate = wxPyBeginAllowThreads();
8939 wxLog::DontCreateOnDemand();
8940
8941 wxPyEndAllowThreads(__tstate);
8942 if (PyErr_Occurred()) SWIG_fail;
8943 }
8944 Py_INCREF(Py_None); resultobj = Py_None;
8945 return resultobj;
8946 fail:
8947 return NULL;
8948 }
8949
8950
8951 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8952 PyObject *resultobj;
8953 wxTraceMask arg1 ;
8954 PyObject * obj0 = 0 ;
8955 char *kwnames[] = {
8956 (char *) "ulMask", NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8960 {
8961 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8962 if (SWIG_arg_fail(1)) SWIG_fail;
8963 }
8964 {
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 wxLog::SetTraceMask(arg1);
8967
8968 wxPyEndAllowThreads(__tstate);
8969 if (PyErr_Occurred()) SWIG_fail;
8970 }
8971 Py_INCREF(Py_None); resultobj = Py_None;
8972 return resultobj;
8973 fail:
8974 return NULL;
8975 }
8976
8977
8978 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj;
8980 wxString *arg1 = 0 ;
8981 bool temp1 = false ;
8982 PyObject * obj0 = 0 ;
8983 char *kwnames[] = {
8984 (char *) "str", NULL
8985 };
8986
8987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
8988 {
8989 arg1 = wxString_in_helper(obj0);
8990 if (arg1 == NULL) SWIG_fail;
8991 temp1 = true;
8992 }
8993 {
8994 PyThreadState* __tstate = wxPyBeginAllowThreads();
8995 wxLog::AddTraceMask((wxString const &)*arg1);
8996
8997 wxPyEndAllowThreads(__tstate);
8998 if (PyErr_Occurred()) SWIG_fail;
8999 }
9000 Py_INCREF(Py_None); resultobj = Py_None;
9001 {
9002 if (temp1)
9003 delete arg1;
9004 }
9005 return resultobj;
9006 fail:
9007 {
9008 if (temp1)
9009 delete arg1;
9010 }
9011 return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj;
9017 wxString *arg1 = 0 ;
9018 bool temp1 = false ;
9019 PyObject * obj0 = 0 ;
9020 char *kwnames[] = {
9021 (char *) "str", NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9025 {
9026 arg1 = wxString_in_helper(obj0);
9027 if (arg1 == NULL) SWIG_fail;
9028 temp1 = true;
9029 }
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 wxLog::RemoveTraceMask((wxString const &)*arg1);
9033
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 Py_INCREF(Py_None); resultobj = Py_None;
9038 {
9039 if (temp1)
9040 delete arg1;
9041 }
9042 return resultobj;
9043 fail:
9044 {
9045 if (temp1)
9046 delete arg1;
9047 }
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 char *kwnames[] = {
9055 NULL
9056 };
9057
9058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 wxLog::ClearTraceMasks();
9062
9063 wxPyEndAllowThreads(__tstate);
9064 if (PyErr_Occurred()) SWIG_fail;
9065 }
9066 Py_INCREF(Py_None); resultobj = Py_None;
9067 return resultobj;
9068 fail:
9069 return NULL;
9070 }
9071
9072
9073 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9074 PyObject *resultobj;
9075 wxArrayString *result;
9076 char *kwnames[] = {
9077 NULL
9078 };
9079
9080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 {
9084 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9085 result = (wxArrayString *) &_result_ref;
9086 }
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 {
9092 resultobj = wxArrayString2PyList_helper(*result);
9093 }
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9101 PyObject *resultobj;
9102 wxChar *arg1 = (wxChar *) 0 ;
9103 PyObject * obj0 = 0 ;
9104 char *kwnames[] = {
9105 (char *) "ts", NULL
9106 };
9107
9108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9110 if (SWIG_arg_fail(1)) SWIG_fail;
9111 {
9112 PyThreadState* __tstate = wxPyBeginAllowThreads();
9113 wxLog::SetTimestamp((wxChar const *)arg1);
9114
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 Py_INCREF(Py_None); resultobj = Py_None;
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj;
9127 bool result;
9128 char *kwnames[] = {
9129 NULL
9130 };
9131
9132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9133 {
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 result = (bool)wxLog::GetVerbose();
9136
9137 wxPyEndAllowThreads(__tstate);
9138 if (PyErr_Occurred()) SWIG_fail;
9139 }
9140 {
9141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9142 }
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
9149 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj;
9151 wxTraceMask result;
9152 char *kwnames[] = {
9153 NULL
9154 };
9155
9156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (wxTraceMask)wxLog::GetTraceMask();
9160
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 {
9165 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9166 }
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9174 PyObject *resultobj;
9175 wxChar *arg1 = (wxChar *) 0 ;
9176 bool result;
9177 PyObject * obj0 = 0 ;
9178 char *kwnames[] = {
9179 (char *) "mask", NULL
9180 };
9181
9182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9184 if (SWIG_arg_fail(1)) SWIG_fail;
9185 {
9186 PyThreadState* __tstate = wxPyBeginAllowThreads();
9187 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9188
9189 wxPyEndAllowThreads(__tstate);
9190 if (PyErr_Occurred()) SWIG_fail;
9191 }
9192 {
9193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9194 }
9195 return resultobj;
9196 fail:
9197 return NULL;
9198 }
9199
9200
9201 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj;
9203 wxLogLevel result;
9204 char *kwnames[] = {
9205 NULL
9206 };
9207
9208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9209 {
9210 PyThreadState* __tstate = wxPyBeginAllowThreads();
9211 result = (wxLogLevel)wxLog::GetLogLevel();
9212
9213 wxPyEndAllowThreads(__tstate);
9214 if (PyErr_Occurred()) SWIG_fail;
9215 }
9216 {
9217 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9218 }
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj;
9227 wxChar *result;
9228 char *kwnames[] = {
9229 NULL
9230 };
9231
9232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 result = (wxChar *)wxLog::GetTimestamp();
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9248 PyObject *resultobj;
9249 wxString result;
9250 char *kwnames[] = {
9251 NULL
9252 };
9253
9254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = Log_TimeStamp();
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 {
9263 #if wxUSE_UNICODE
9264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9265 #else
9266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9267 #endif
9268 }
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj;
9277 wxLog *arg1 = (wxLog *) 0 ;
9278 PyObject * obj0 = 0 ;
9279 char *kwnames[] = {
9280 (char *) "self", NULL
9281 };
9282
9283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9285 if (SWIG_arg_fail(1)) SWIG_fail;
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 wxLog_Destroy(arg1);
9289
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 Py_INCREF(Py_None); resultobj = Py_None;
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9301 PyObject *obj;
9302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9303 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9304 Py_INCREF(obj);
9305 return Py_BuildValue((char *)"");
9306 }
9307 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9308 PyObject *resultobj;
9309 wxLogStderr *result;
9310 char *kwnames[] = {
9311 NULL
9312 };
9313
9314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 result = (wxLogStderr *)new wxLogStderr();
9318
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9330 PyObject *obj;
9331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9332 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9333 Py_INCREF(obj);
9334 return Py_BuildValue((char *)"");
9335 }
9336 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9337 PyObject *resultobj;
9338 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9339 wxLogTextCtrl *result;
9340 PyObject * obj0 = 0 ;
9341 char *kwnames[] = {
9342 (char *) "pTextCtrl", NULL
9343 };
9344
9345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9347 if (SWIG_arg_fail(1)) SWIG_fail;
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9351
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9356 return resultobj;
9357 fail:
9358 return NULL;
9359 }
9360
9361
9362 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9363 PyObject *obj;
9364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9365 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9366 Py_INCREF(obj);
9367 return Py_BuildValue((char *)"");
9368 }
9369 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj;
9371 wxLogGui *result;
9372 char *kwnames[] = {
9373 NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9377 {
9378 PyThreadState* __tstate = wxPyBeginAllowThreads();
9379 result = (wxLogGui *)new wxLogGui();
9380
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9385 return resultobj;
9386 fail:
9387 return NULL;
9388 }
9389
9390
9391 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9392 PyObject *obj;
9393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9394 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9395 Py_INCREF(obj);
9396 return Py_BuildValue((char *)"");
9397 }
9398 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9399 PyObject *resultobj;
9400 wxFrame *arg1 = (wxFrame *) 0 ;
9401 wxString *arg2 = 0 ;
9402 bool arg3 = (bool) true ;
9403 bool arg4 = (bool) true ;
9404 wxLogWindow *result;
9405 bool temp2 = false ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 PyObject * obj2 = 0 ;
9409 PyObject * obj3 = 0 ;
9410 char *kwnames[] = {
9411 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9416 if (SWIG_arg_fail(1)) SWIG_fail;
9417 {
9418 arg2 = wxString_in_helper(obj1);
9419 if (arg2 == NULL) SWIG_fail;
9420 temp2 = true;
9421 }
9422 if (obj2) {
9423 {
9424 arg3 = (bool)(SWIG_As_bool(obj2));
9425 if (SWIG_arg_fail(3)) SWIG_fail;
9426 }
9427 }
9428 if (obj3) {
9429 {
9430 arg4 = (bool)(SWIG_As_bool(obj3));
9431 if (SWIG_arg_fail(4)) SWIG_fail;
9432 }
9433 }
9434 {
9435 PyThreadState* __tstate = wxPyBeginAllowThreads();
9436 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9437
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return resultobj;
9447 fail:
9448 {
9449 if (temp2)
9450 delete arg2;
9451 }
9452 return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9459 bool arg2 = (bool) true ;
9460 PyObject * obj0 = 0 ;
9461 PyObject * obj1 = 0 ;
9462 char *kwnames[] = {
9463 (char *) "self",(char *) "bShow", NULL
9464 };
9465
9466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9468 if (SWIG_arg_fail(1)) SWIG_fail;
9469 if (obj1) {
9470 {
9471 arg2 = (bool)(SWIG_As_bool(obj1));
9472 if (SWIG_arg_fail(2)) SWIG_fail;
9473 }
9474 }
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 (arg1)->Show(arg2);
9478
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 Py_INCREF(Py_None); resultobj = Py_None;
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9492 wxFrame *result;
9493 PyObject * obj0 = 0 ;
9494 char *kwnames[] = {
9495 (char *) "self", NULL
9496 };
9497
9498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9500 if (SWIG_arg_fail(1)) SWIG_fail;
9501 {
9502 PyThreadState* __tstate = wxPyBeginAllowThreads();
9503 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9504
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 {
9509 resultobj = wxPyMake_wxObject(result, 0);
9510 }
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj;
9519 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9520 wxLog *result;
9521 PyObject * obj0 = 0 ;
9522 char *kwnames[] = {
9523 (char *) "self", NULL
9524 };
9525
9526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9528 if (SWIG_arg_fail(1)) SWIG_fail;
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9532
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj;
9545 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9546 bool result;
9547 PyObject * obj0 = 0 ;
9548 char *kwnames[] = {
9549 (char *) "self", NULL
9550 };
9551
9552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9554 if (SWIG_arg_fail(1)) SWIG_fail;
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9558
9559 wxPyEndAllowThreads(__tstate);
9560 if (PyErr_Occurred()) SWIG_fail;
9561 }
9562 {
9563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9564 }
9565 return resultobj;
9566 fail:
9567 return NULL;
9568 }
9569
9570
9571 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9572 PyObject *resultobj;
9573 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9574 bool arg2 ;
9575 PyObject * obj0 = 0 ;
9576 PyObject * obj1 = 0 ;
9577 char *kwnames[] = {
9578 (char *) "self",(char *) "bDoPass", NULL
9579 };
9580
9581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9583 if (SWIG_arg_fail(1)) SWIG_fail;
9584 {
9585 arg2 = (bool)(SWIG_As_bool(obj1));
9586 if (SWIG_arg_fail(2)) SWIG_fail;
9587 }
9588 {
9589 PyThreadState* __tstate = wxPyBeginAllowThreads();
9590 (arg1)->PassMessages(arg2);
9591
9592 wxPyEndAllowThreads(__tstate);
9593 if (PyErr_Occurred()) SWIG_fail;
9594 }
9595 Py_INCREF(Py_None); resultobj = Py_None;
9596 return resultobj;
9597 fail:
9598 return NULL;
9599 }
9600
9601
9602 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9603 PyObject *obj;
9604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9605 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9606 Py_INCREF(obj);
9607 return Py_BuildValue((char *)"");
9608 }
9609 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9610 PyObject *resultobj;
9611 wxLog *arg1 = (wxLog *) 0 ;
9612 wxLogChain *result;
9613 PyObject * obj0 = 0 ;
9614 char *kwnames[] = {
9615 (char *) "logger", NULL
9616 };
9617
9618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9620 if (SWIG_arg_fail(1)) SWIG_fail;
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 result = (wxLogChain *)new wxLogChain(arg1);
9624
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9629 return resultobj;
9630 fail:
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxLogChain *arg1 = (wxLogChain *) 0 ;
9638 wxLog *arg2 = (wxLog *) 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char *kwnames[] = {
9642 (char *) "self",(char *) "logger", NULL
9643 };
9644
9645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9647 if (SWIG_arg_fail(1)) SWIG_fail;
9648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9649 if (SWIG_arg_fail(2)) SWIG_fail;
9650 {
9651 PyThreadState* __tstate = wxPyBeginAllowThreads();
9652 (arg1)->SetLog(arg2);
9653
9654 wxPyEndAllowThreads(__tstate);
9655 if (PyErr_Occurred()) SWIG_fail;
9656 }
9657 Py_INCREF(Py_None); resultobj = Py_None;
9658 return resultobj;
9659 fail:
9660 return NULL;
9661 }
9662
9663
9664 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9665 PyObject *resultobj;
9666 wxLogChain *arg1 = (wxLogChain *) 0 ;
9667 bool arg2 ;
9668 PyObject * obj0 = 0 ;
9669 PyObject * obj1 = 0 ;
9670 char *kwnames[] = {
9671 (char *) "self",(char *) "bDoPass", NULL
9672 };
9673
9674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9676 if (SWIG_arg_fail(1)) SWIG_fail;
9677 {
9678 arg2 = (bool)(SWIG_As_bool(obj1));
9679 if (SWIG_arg_fail(2)) SWIG_fail;
9680 }
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 (arg1)->PassMessages(arg2);
9684
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 Py_INCREF(Py_None); resultobj = Py_None;
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9696 PyObject *resultobj;
9697 wxLogChain *arg1 = (wxLogChain *) 0 ;
9698 bool result;
9699 PyObject * obj0 = 0 ;
9700 char *kwnames[] = {
9701 (char *) "self", NULL
9702 };
9703
9704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(1)) SWIG_fail;
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (bool)(arg1)->IsPassingMessages();
9710
9711 wxPyEndAllowThreads(__tstate);
9712 if (PyErr_Occurred()) SWIG_fail;
9713 }
9714 {
9715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9716 }
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj;
9725 wxLogChain *arg1 = (wxLogChain *) 0 ;
9726 wxLog *result;
9727 PyObject * obj0 = 0 ;
9728 char *kwnames[] = {
9729 (char *) "self", NULL
9730 };
9731
9732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9734 if (SWIG_arg_fail(1)) SWIG_fail;
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 result = (wxLog *)(arg1)->GetOldLog();
9738
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9750 PyObject *obj;
9751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9752 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9753 Py_INCREF(obj);
9754 return Py_BuildValue((char *)"");
9755 }
9756 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj;
9758 unsigned long result;
9759 char *kwnames[] = {
9760 NULL
9761 };
9762
9763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (unsigned long)wxSysErrorCode();
9767
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 {
9772 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9773 }
9774 return resultobj;
9775 fail:
9776 return NULL;
9777 }
9778
9779
9780 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9781 PyObject *resultobj;
9782 unsigned long arg1 = (unsigned long) 0 ;
9783 wxString result;
9784 PyObject * obj0 = 0 ;
9785 char *kwnames[] = {
9786 (char *) "nErrCode", NULL
9787 };
9788
9789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9790 if (obj0) {
9791 {
9792 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9793 if (SWIG_arg_fail(1)) SWIG_fail;
9794 }
9795 }
9796 {
9797 PyThreadState* __tstate = wxPyBeginAllowThreads();
9798 result = wxSysErrorMsg(arg1);
9799
9800 wxPyEndAllowThreads(__tstate);
9801 if (PyErr_Occurred()) SWIG_fail;
9802 }
9803 {
9804 #if wxUSE_UNICODE
9805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9806 #else
9807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9808 #endif
9809 }
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj;
9818 wxString *arg1 = 0 ;
9819 bool temp1 = false ;
9820 PyObject * obj0 = 0 ;
9821 char *kwnames[] = {
9822 (char *) "msg", NULL
9823 };
9824
9825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9826 {
9827 arg1 = wxString_in_helper(obj0);
9828 if (arg1 == NULL) SWIG_fail;
9829 temp1 = true;
9830 }
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 wxPyLogFatalError((wxString const &)*arg1);
9834
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 Py_INCREF(Py_None); resultobj = Py_None;
9839 {
9840 if (temp1)
9841 delete arg1;
9842 }
9843 return resultobj;
9844 fail:
9845 {
9846 if (temp1)
9847 delete arg1;
9848 }
9849 return NULL;
9850 }
9851
9852
9853 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxString *arg1 = 0 ;
9856 bool temp1 = false ;
9857 PyObject * obj0 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "msg", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9863 {
9864 arg1 = wxString_in_helper(obj0);
9865 if (arg1 == NULL) SWIG_fail;
9866 temp1 = true;
9867 }
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 wxPyLogError((wxString const &)*arg1);
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 Py_INCREF(Py_None); resultobj = Py_None;
9876 {
9877 if (temp1)
9878 delete arg1;
9879 }
9880 return resultobj;
9881 fail:
9882 {
9883 if (temp1)
9884 delete arg1;
9885 }
9886 return NULL;
9887 }
9888
9889
9890 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9891 PyObject *resultobj;
9892 wxString *arg1 = 0 ;
9893 bool temp1 = false ;
9894 PyObject * obj0 = 0 ;
9895 char *kwnames[] = {
9896 (char *) "msg", NULL
9897 };
9898
9899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9900 {
9901 arg1 = wxString_in_helper(obj0);
9902 if (arg1 == NULL) SWIG_fail;
9903 temp1 = true;
9904 }
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 wxPyLogWarning((wxString const &)*arg1);
9908
9909 wxPyEndAllowThreads(__tstate);
9910 if (PyErr_Occurred()) SWIG_fail;
9911 }
9912 Py_INCREF(Py_None); resultobj = Py_None;
9913 {
9914 if (temp1)
9915 delete arg1;
9916 }
9917 return resultobj;
9918 fail:
9919 {
9920 if (temp1)
9921 delete arg1;
9922 }
9923 return NULL;
9924 }
9925
9926
9927 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9928 PyObject *resultobj;
9929 wxString *arg1 = 0 ;
9930 bool temp1 = false ;
9931 PyObject * obj0 = 0 ;
9932 char *kwnames[] = {
9933 (char *) "msg", NULL
9934 };
9935
9936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9937 {
9938 arg1 = wxString_in_helper(obj0);
9939 if (arg1 == NULL) SWIG_fail;
9940 temp1 = true;
9941 }
9942 {
9943 PyThreadState* __tstate = wxPyBeginAllowThreads();
9944 wxPyLogMessage((wxString const &)*arg1);
9945
9946 wxPyEndAllowThreads(__tstate);
9947 if (PyErr_Occurred()) SWIG_fail;
9948 }
9949 Py_INCREF(Py_None); resultobj = Py_None;
9950 {
9951 if (temp1)
9952 delete arg1;
9953 }
9954 return resultobj;
9955 fail:
9956 {
9957 if (temp1)
9958 delete arg1;
9959 }
9960 return NULL;
9961 }
9962
9963
9964 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9965 PyObject *resultobj;
9966 wxString *arg1 = 0 ;
9967 bool temp1 = false ;
9968 PyObject * obj0 = 0 ;
9969 char *kwnames[] = {
9970 (char *) "msg", NULL
9971 };
9972
9973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9974 {
9975 arg1 = wxString_in_helper(obj0);
9976 if (arg1 == NULL) SWIG_fail;
9977 temp1 = true;
9978 }
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 wxPyLogInfo((wxString const &)*arg1);
9982
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 Py_INCREF(Py_None); resultobj = Py_None;
9987 {
9988 if (temp1)
9989 delete arg1;
9990 }
9991 return resultobj;
9992 fail:
9993 {
9994 if (temp1)
9995 delete arg1;
9996 }
9997 return NULL;
9998 }
9999
10000
10001 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj;
10003 wxString *arg1 = 0 ;
10004 bool temp1 = false ;
10005 PyObject * obj0 = 0 ;
10006 char *kwnames[] = {
10007 (char *) "msg", NULL
10008 };
10009
10010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10011 {
10012 arg1 = wxString_in_helper(obj0);
10013 if (arg1 == NULL) SWIG_fail;
10014 temp1 = true;
10015 }
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 wxPyLogDebug((wxString const &)*arg1);
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 Py_INCREF(Py_None); resultobj = Py_None;
10024 {
10025 if (temp1)
10026 delete arg1;
10027 }
10028 return resultobj;
10029 fail:
10030 {
10031 if (temp1)
10032 delete arg1;
10033 }
10034 return NULL;
10035 }
10036
10037
10038 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 wxString *arg1 = 0 ;
10041 bool temp1 = false ;
10042 PyObject * obj0 = 0 ;
10043 char *kwnames[] = {
10044 (char *) "msg", NULL
10045 };
10046
10047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10048 {
10049 arg1 = wxString_in_helper(obj0);
10050 if (arg1 == NULL) SWIG_fail;
10051 temp1 = true;
10052 }
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 wxPyLogVerbose((wxString const &)*arg1);
10056
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 Py_INCREF(Py_None); resultobj = Py_None;
10061 {
10062 if (temp1)
10063 delete arg1;
10064 }
10065 return resultobj;
10066 fail:
10067 {
10068 if (temp1)
10069 delete arg1;
10070 }
10071 return NULL;
10072 }
10073
10074
10075 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10076 PyObject *resultobj;
10077 wxString *arg1 = 0 ;
10078 bool temp1 = false ;
10079 PyObject * obj0 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "msg", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10085 {
10086 arg1 = wxString_in_helper(obj0);
10087 if (arg1 == NULL) SWIG_fail;
10088 temp1 = true;
10089 }
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 wxPyLogStatus((wxString const &)*arg1);
10093
10094 wxPyEndAllowThreads(__tstate);
10095 if (PyErr_Occurred()) SWIG_fail;
10096 }
10097 Py_INCREF(Py_None); resultobj = Py_None;
10098 {
10099 if (temp1)
10100 delete arg1;
10101 }
10102 return resultobj;
10103 fail:
10104 {
10105 if (temp1)
10106 delete arg1;
10107 }
10108 return NULL;
10109 }
10110
10111
10112 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10113 PyObject *resultobj;
10114 wxFrame *arg1 = (wxFrame *) 0 ;
10115 wxString *arg2 = 0 ;
10116 bool temp2 = false ;
10117 PyObject * obj0 = 0 ;
10118 PyObject * obj1 = 0 ;
10119 char *kwnames[] = {
10120 (char *) "pFrame",(char *) "msg", NULL
10121 };
10122
10123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10125 if (SWIG_arg_fail(1)) SWIG_fail;
10126 {
10127 arg2 = wxString_in_helper(obj1);
10128 if (arg2 == NULL) SWIG_fail;
10129 temp2 = true;
10130 }
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10134
10135 wxPyEndAllowThreads(__tstate);
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 Py_INCREF(Py_None); resultobj = Py_None;
10139 {
10140 if (temp2)
10141 delete arg2;
10142 }
10143 return resultobj;
10144 fail:
10145 {
10146 if (temp2)
10147 delete arg2;
10148 }
10149 return NULL;
10150 }
10151
10152
10153 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj;
10155 wxString *arg1 = 0 ;
10156 bool temp1 = false ;
10157 PyObject * obj0 = 0 ;
10158 char *kwnames[] = {
10159 (char *) "msg", NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10163 {
10164 arg1 = wxString_in_helper(obj0);
10165 if (arg1 == NULL) SWIG_fail;
10166 temp1 = true;
10167 }
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 wxPyLogSysError((wxString const &)*arg1);
10171
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 Py_INCREF(Py_None); resultobj = Py_None;
10176 {
10177 if (temp1)
10178 delete arg1;
10179 }
10180 return resultobj;
10181 fail:
10182 {
10183 if (temp1)
10184 delete arg1;
10185 }
10186 return NULL;
10187 }
10188
10189
10190 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10191 PyObject *resultobj;
10192 unsigned long arg1 ;
10193 wxString *arg2 = 0 ;
10194 bool temp2 = false ;
10195 PyObject * obj0 = 0 ;
10196 PyObject * obj1 = 0 ;
10197 char *kwnames[] = {
10198 (char *) "level",(char *) "msg", NULL
10199 };
10200
10201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10202 {
10203 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10204 if (SWIG_arg_fail(1)) SWIG_fail;
10205 }
10206 {
10207 arg2 = wxString_in_helper(obj1);
10208 if (arg2 == NULL) SWIG_fail;
10209 temp2 = true;
10210 }
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10214
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 Py_INCREF(Py_None); resultobj = Py_None;
10219 {
10220 if (temp2)
10221 delete arg2;
10222 }
10223 return resultobj;
10224 fail:
10225 {
10226 if (temp2)
10227 delete arg2;
10228 }
10229 return NULL;
10230 }
10231
10232
10233 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10234 PyObject *resultobj;
10235 unsigned long arg1 ;
10236 wxString *arg2 = 0 ;
10237 bool temp2 = false ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240
10241 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10242 {
10243 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10244 if (SWIG_arg_fail(1)) SWIG_fail;
10245 }
10246 {
10247 arg2 = wxString_in_helper(obj1);
10248 if (arg2 == NULL) SWIG_fail;
10249 temp2 = true;
10250 }
10251 {
10252 PyThreadState* __tstate = wxPyBeginAllowThreads();
10253 wxPyLogTrace(arg1,(wxString const &)*arg2);
10254
10255 wxPyEndAllowThreads(__tstate);
10256 if (PyErr_Occurred()) SWIG_fail;
10257 }
10258 Py_INCREF(Py_None); resultobj = Py_None;
10259 {
10260 if (temp2)
10261 delete arg2;
10262 }
10263 return resultobj;
10264 fail:
10265 {
10266 if (temp2)
10267 delete arg2;
10268 }
10269 return NULL;
10270 }
10271
10272
10273 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10274 PyObject *resultobj;
10275 wxString *arg1 = 0 ;
10276 wxString *arg2 = 0 ;
10277 bool temp1 = false ;
10278 bool temp2 = false ;
10279 PyObject * obj0 = 0 ;
10280 PyObject * obj1 = 0 ;
10281
10282 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10283 {
10284 arg1 = wxString_in_helper(obj0);
10285 if (arg1 == NULL) SWIG_fail;
10286 temp1 = true;
10287 }
10288 {
10289 arg2 = wxString_in_helper(obj1);
10290 if (arg2 == NULL) SWIG_fail;
10291 temp2 = true;
10292 }
10293 {
10294 PyThreadState* __tstate = wxPyBeginAllowThreads();
10295 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10296
10297 wxPyEndAllowThreads(__tstate);
10298 if (PyErr_Occurred()) SWIG_fail;
10299 }
10300 Py_INCREF(Py_None); resultobj = Py_None;
10301 {
10302 if (temp1)
10303 delete arg1;
10304 }
10305 {
10306 if (temp2)
10307 delete arg2;
10308 }
10309 return resultobj;
10310 fail:
10311 {
10312 if (temp1)
10313 delete arg1;
10314 }
10315 {
10316 if (temp2)
10317 delete arg2;
10318 }
10319 return NULL;
10320 }
10321
10322
10323 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10324 int argc;
10325 PyObject *argv[3];
10326 int ii;
10327
10328 argc = PyObject_Length(args);
10329 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10330 argv[ii] = PyTuple_GetItem(args,ii);
10331 }
10332 if (argc == 2) {
10333 int _v;
10334 {
10335 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10336 }
10337 if (_v) {
10338 {
10339 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10340 }
10341 if (_v) {
10342 return _wrap_LogTrace__SWIG_1(self,args);
10343 }
10344 }
10345 }
10346 if (argc == 2) {
10347 int _v;
10348 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10349 if (_v) {
10350 {
10351 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10352 }
10353 if (_v) {
10354 return _wrap_LogTrace__SWIG_0(self,args);
10355 }
10356 }
10357 }
10358
10359 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10360 return NULL;
10361 }
10362
10363
10364 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10365 PyObject *resultobj;
10366 wxString *arg1 = 0 ;
10367 wxString *arg2 = 0 ;
10368 bool temp1 = false ;
10369 bool temp2 = false ;
10370 PyObject * obj0 = 0 ;
10371 PyObject * obj1 = 0 ;
10372 char *kwnames[] = {
10373 (char *) "title",(char *) "text", NULL
10374 };
10375
10376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10377 {
10378 arg1 = wxString_in_helper(obj0);
10379 if (arg1 == NULL) SWIG_fail;
10380 temp1 = true;
10381 }
10382 {
10383 arg2 = wxString_in_helper(obj1);
10384 if (arg2 == NULL) SWIG_fail;
10385 temp2 = true;
10386 }
10387 {
10388 PyThreadState* __tstate = wxPyBeginAllowThreads();
10389 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10390
10391 wxPyEndAllowThreads(__tstate);
10392 if (PyErr_Occurred()) SWIG_fail;
10393 }
10394 Py_INCREF(Py_None); resultobj = Py_None;
10395 {
10396 if (temp1)
10397 delete arg1;
10398 }
10399 {
10400 if (temp2)
10401 delete arg2;
10402 }
10403 return resultobj;
10404 fail:
10405 {
10406 if (temp1)
10407 delete arg1;
10408 }
10409 {
10410 if (temp2)
10411 delete arg2;
10412 }
10413 return NULL;
10414 }
10415
10416
10417 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10418 PyObject *resultobj;
10419 wxLogNull *result;
10420 char *kwnames[] = {
10421 NULL
10422 };
10423
10424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (wxLogNull *)new wxLogNull();
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10433 return resultobj;
10434 fail:
10435 return NULL;
10436 }
10437
10438
10439 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj;
10441 wxLogNull *arg1 = (wxLogNull *) 0 ;
10442 PyObject * obj0 = 0 ;
10443 char *kwnames[] = {
10444 (char *) "self", NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10449 if (SWIG_arg_fail(1)) SWIG_fail;
10450 {
10451 PyThreadState* __tstate = wxPyBeginAllowThreads();
10452 delete arg1;
10453
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 Py_INCREF(Py_None); resultobj = Py_None;
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10465 PyObject *obj;
10466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10467 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10468 Py_INCREF(obj);
10469 return Py_BuildValue((char *)"");
10470 }
10471 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10472 PyObject *resultobj;
10473 wxPyLog *result;
10474 char *kwnames[] = {
10475 NULL
10476 };
10477
10478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (wxPyLog *)new wxPyLog();
10482
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10487 return resultobj;
10488 fail:
10489 return NULL;
10490 }
10491
10492
10493 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10494 PyObject *resultobj;
10495 wxPyLog *arg1 = (wxPyLog *) 0 ;
10496 PyObject *arg2 = (PyObject *) 0 ;
10497 PyObject *arg3 = (PyObject *) 0 ;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 PyObject * obj2 = 0 ;
10501 char *kwnames[] = {
10502 (char *) "self",(char *) "self",(char *) "_class", NULL
10503 };
10504
10505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10507 if (SWIG_arg_fail(1)) SWIG_fail;
10508 arg2 = obj1;
10509 arg3 = obj2;
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 (arg1)->_setCallbackInfo(arg2,arg3);
10513
10514 wxPyEndAllowThreads(__tstate);
10515 if (PyErr_Occurred()) SWIG_fail;
10516 }
10517 Py_INCREF(Py_None); resultobj = Py_None;
10518 return resultobj;
10519 fail:
10520 return NULL;
10521 }
10522
10523
10524 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10525 PyObject *obj;
10526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10527 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10528 Py_INCREF(obj);
10529 return Py_BuildValue((char *)"");
10530 }
10531 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10532 PyObject *resultobj;
10533 int arg1 ;
10534 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10535 int arg3 = (int) wxKILL_NOCHILDREN ;
10536 wxKillError result;
10537 PyObject * obj0 = 0 ;
10538 PyObject * obj1 = 0 ;
10539 PyObject * obj2 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10545 {
10546 arg1 = (int)(SWIG_As_int(obj0));
10547 if (SWIG_arg_fail(1)) SWIG_fail;
10548 }
10549 if (obj1) {
10550 {
10551 arg2 = (wxSignal)(SWIG_As_int(obj1));
10552 if (SWIG_arg_fail(2)) SWIG_fail;
10553 }
10554 }
10555 if (obj2) {
10556 {
10557 arg3 = (int)(SWIG_As_int(obj2));
10558 if (SWIG_arg_fail(3)) SWIG_fail;
10559 }
10560 }
10561 {
10562 PyThreadState* __tstate = wxPyBeginAllowThreads();
10563 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10564
10565 wxPyEndAllowThreads(__tstate);
10566 if (PyErr_Occurred()) SWIG_fail;
10567 }
10568 resultobj = SWIG_From_int((result));
10569 return resultobj;
10570 fail:
10571 return NULL;
10572 }
10573
10574
10575 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10576 PyObject *resultobj;
10577 int arg1 ;
10578 bool result;
10579 PyObject * obj0 = 0 ;
10580 char *kwnames[] = {
10581 (char *) "pid", NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10585 {
10586 arg1 = (int)(SWIG_As_int(obj0));
10587 if (SWIG_arg_fail(1)) SWIG_fail;
10588 }
10589 {
10590 PyThreadState* __tstate = wxPyBeginAllowThreads();
10591 result = (bool)wxPyProcess::Exists(arg1);
10592
10593 wxPyEndAllowThreads(__tstate);
10594 if (PyErr_Occurred()) SWIG_fail;
10595 }
10596 {
10597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10598 }
10599 return resultobj;
10600 fail:
10601 return NULL;
10602 }
10603
10604
10605 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10606 PyObject *resultobj;
10607 wxString *arg1 = 0 ;
10608 int arg2 = (int) wxEXEC_ASYNC ;
10609 wxPyProcess *result;
10610 bool temp1 = false ;
10611 PyObject * obj0 = 0 ;
10612 PyObject * obj1 = 0 ;
10613 char *kwnames[] = {
10614 (char *) "cmd",(char *) "flags", NULL
10615 };
10616
10617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10618 {
10619 arg1 = wxString_in_helper(obj0);
10620 if (arg1 == NULL) SWIG_fail;
10621 temp1 = true;
10622 }
10623 if (obj1) {
10624 {
10625 arg2 = (int)(SWIG_As_int(obj1));
10626 if (SWIG_arg_fail(2)) SWIG_fail;
10627 }
10628 }
10629 {
10630 PyThreadState* __tstate = wxPyBeginAllowThreads();
10631 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10632
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10637 {
10638 if (temp1)
10639 delete arg1;
10640 }
10641 return resultobj;
10642 fail:
10643 {
10644 if (temp1)
10645 delete arg1;
10646 }
10647 return NULL;
10648 }
10649
10650
10651 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10652 PyObject *resultobj;
10653 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10654 int arg2 = (int) -1 ;
10655 wxPyProcess *result;
10656 PyObject * obj0 = 0 ;
10657 PyObject * obj1 = 0 ;
10658 char *kwnames[] = {
10659 (char *) "parent",(char *) "id", NULL
10660 };
10661
10662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10663 if (obj0) {
10664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10665 if (SWIG_arg_fail(1)) SWIG_fail;
10666 }
10667 if (obj1) {
10668 {
10669 arg2 = (int)(SWIG_As_int(obj1));
10670 if (SWIG_arg_fail(2)) SWIG_fail;
10671 }
10672 }
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10676
10677 wxPyEndAllowThreads(__tstate);
10678 if (PyErr_Occurred()) SWIG_fail;
10679 }
10680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10681 return resultobj;
10682 fail:
10683 return NULL;
10684 }
10685
10686
10687 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10688 PyObject *resultobj;
10689 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10690 PyObject *arg2 = (PyObject *) 0 ;
10691 PyObject *arg3 = (PyObject *) 0 ;
10692 PyObject * obj0 = 0 ;
10693 PyObject * obj1 = 0 ;
10694 PyObject * obj2 = 0 ;
10695 char *kwnames[] = {
10696 (char *) "self",(char *) "self",(char *) "_class", NULL
10697 };
10698
10699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10701 if (SWIG_arg_fail(1)) SWIG_fail;
10702 arg2 = obj1;
10703 arg3 = obj2;
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 (arg1)->_setCallbackInfo(arg2,arg3);
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 Py_INCREF(Py_None); resultobj = Py_None;
10712 return resultobj;
10713 fail:
10714 return NULL;
10715 }
10716
10717
10718 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10719 PyObject *resultobj;
10720 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10721 int arg2 ;
10722 int arg3 ;
10723 PyObject * obj0 = 0 ;
10724 PyObject * obj1 = 0 ;
10725 PyObject * obj2 = 0 ;
10726 char *kwnames[] = {
10727 (char *) "self",(char *) "pid",(char *) "status", NULL
10728 };
10729
10730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10732 if (SWIG_arg_fail(1)) SWIG_fail;
10733 {
10734 arg2 = (int)(SWIG_As_int(obj1));
10735 if (SWIG_arg_fail(2)) SWIG_fail;
10736 }
10737 {
10738 arg3 = (int)(SWIG_As_int(obj2));
10739 if (SWIG_arg_fail(3)) SWIG_fail;
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 (arg1)->base_OnTerminate(arg2,arg3);
10744
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 Py_INCREF(Py_None); resultobj = Py_None;
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10758 PyObject * obj0 = 0 ;
10759 char *kwnames[] = {
10760 (char *) "self", NULL
10761 };
10762
10763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10765 if (SWIG_arg_fail(1)) SWIG_fail;
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 (arg1)->Redirect();
10769
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 Py_INCREF(Py_None); resultobj = Py_None;
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj;
10782 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10783 bool result;
10784 PyObject * obj0 = 0 ;
10785 char *kwnames[] = {
10786 (char *) "self", NULL
10787 };
10788
10789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10791 if (SWIG_arg_fail(1)) SWIG_fail;
10792 {
10793 PyThreadState* __tstate = wxPyBeginAllowThreads();
10794 result = (bool)(arg1)->IsRedirected();
10795
10796 wxPyEndAllowThreads(__tstate);
10797 if (PyErr_Occurred()) SWIG_fail;
10798 }
10799 {
10800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10801 }
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj;
10810 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10811 PyObject * obj0 = 0 ;
10812 char *kwnames[] = {
10813 (char *) "self", NULL
10814 };
10815
10816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10818 if (SWIG_arg_fail(1)) SWIG_fail;
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 (arg1)->Detach();
10822
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 Py_INCREF(Py_None); resultobj = Py_None;
10827 return resultobj;
10828 fail:
10829 return NULL;
10830 }
10831
10832
10833 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj;
10835 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10836 wxInputStream *result;
10837 PyObject * obj0 = 0 ;
10838 char *kwnames[] = {
10839 (char *) "self", NULL
10840 };
10841
10842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10844 if (SWIG_arg_fail(1)) SWIG_fail;
10845 {
10846 PyThreadState* __tstate = wxPyBeginAllowThreads();
10847 result = (wxInputStream *)(arg1)->GetInputStream();
10848
10849 wxPyEndAllowThreads(__tstate);
10850 if (PyErr_Occurred()) SWIG_fail;
10851 }
10852 {
10853 wxPyInputStream * _ptr = NULL;
10854
10855 if (result) {
10856 _ptr = new wxPyInputStream(result);
10857 }
10858 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10859 }
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj;
10868 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10869 wxInputStream *result;
10870 PyObject * obj0 = 0 ;
10871 char *kwnames[] = {
10872 (char *) "self", NULL
10873 };
10874
10875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10877 if (SWIG_arg_fail(1)) SWIG_fail;
10878 {
10879 PyThreadState* __tstate = wxPyBeginAllowThreads();
10880 result = (wxInputStream *)(arg1)->GetErrorStream();
10881
10882 wxPyEndAllowThreads(__tstate);
10883 if (PyErr_Occurred()) SWIG_fail;
10884 }
10885 {
10886 wxPyInputStream * _ptr = NULL;
10887
10888 if (result) {
10889 _ptr = new wxPyInputStream(result);
10890 }
10891 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10892 }
10893 return resultobj;
10894 fail:
10895 return NULL;
10896 }
10897
10898
10899 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10900 PyObject *resultobj;
10901 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10902 wxOutputStream *result;
10903 PyObject * obj0 = 0 ;
10904 char *kwnames[] = {
10905 (char *) "self", NULL
10906 };
10907
10908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10910 if (SWIG_arg_fail(1)) SWIG_fail;
10911 {
10912 PyThreadState* __tstate = wxPyBeginAllowThreads();
10913 result = (wxOutputStream *)(arg1)->GetOutputStream();
10914
10915 wxPyEndAllowThreads(__tstate);
10916 if (PyErr_Occurred()) SWIG_fail;
10917 }
10918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10919 return resultobj;
10920 fail:
10921 return NULL;
10922 }
10923
10924
10925 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10926 PyObject *resultobj;
10927 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10928 PyObject * obj0 = 0 ;
10929 char *kwnames[] = {
10930 (char *) "self", NULL
10931 };
10932
10933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10935 if (SWIG_arg_fail(1)) SWIG_fail;
10936 {
10937 PyThreadState* __tstate = wxPyBeginAllowThreads();
10938 (arg1)->CloseOutput();
10939
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 Py_INCREF(Py_None); resultobj = Py_None;
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj;
10952 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10953 bool result;
10954 PyObject * obj0 = 0 ;
10955 char *kwnames[] = {
10956 (char *) "self", NULL
10957 };
10958
10959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10961 if (SWIG_arg_fail(1)) SWIG_fail;
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10965
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 {
10970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10971 }
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj;
10980 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10981 bool result;
10982 PyObject * obj0 = 0 ;
10983 char *kwnames[] = {
10984 (char *) "self", NULL
10985 };
10986
10987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
10988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10989 if (SWIG_arg_fail(1)) SWIG_fail;
10990 {
10991 PyThreadState* __tstate = wxPyBeginAllowThreads();
10992 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
10993
10994 wxPyEndAllowThreads(__tstate);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 {
10998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10999 }
11000 return resultobj;
11001 fail:
11002 return NULL;
11003 }
11004
11005
11006 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj;
11008 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11009 bool result;
11010 PyObject * obj0 = 0 ;
11011 char *kwnames[] = {
11012 (char *) "self", NULL
11013 };
11014
11015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11017 if (SWIG_arg_fail(1)) SWIG_fail;
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11021
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 {
11026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11027 }
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11035 PyObject *obj;
11036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11037 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11038 Py_INCREF(obj);
11039 return Py_BuildValue((char *)"");
11040 }
11041 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj;
11043 int arg1 = (int) 0 ;
11044 int arg2 = (int) 0 ;
11045 int arg3 = (int) 0 ;
11046 wxProcessEvent *result;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 PyObject * obj2 = 0 ;
11050 char *kwnames[] = {
11051 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11052 };
11053
11054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11055 if (obj0) {
11056 {
11057 arg1 = (int)(SWIG_As_int(obj0));
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 }
11060 }
11061 if (obj1) {
11062 {
11063 arg2 = (int)(SWIG_As_int(obj1));
11064 if (SWIG_arg_fail(2)) SWIG_fail;
11065 }
11066 }
11067 if (obj2) {
11068 {
11069 arg3 = (int)(SWIG_As_int(obj2));
11070 if (SWIG_arg_fail(3)) SWIG_fail;
11071 }
11072 }
11073 {
11074 PyThreadState* __tstate = wxPyBeginAllowThreads();
11075 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11076
11077 wxPyEndAllowThreads(__tstate);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11081 return resultobj;
11082 fail:
11083 return NULL;
11084 }
11085
11086
11087 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11088 PyObject *resultobj;
11089 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11090 int result;
11091 PyObject * obj0 = 0 ;
11092 char *kwnames[] = {
11093 (char *) "self", NULL
11094 };
11095
11096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11098 if (SWIG_arg_fail(1)) SWIG_fail;
11099 {
11100 PyThreadState* __tstate = wxPyBeginAllowThreads();
11101 result = (int)(arg1)->GetPid();
11102
11103 wxPyEndAllowThreads(__tstate);
11104 if (PyErr_Occurred()) SWIG_fail;
11105 }
11106 {
11107 resultobj = SWIG_From_int((int)(result));
11108 }
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11118 int result;
11119 PyObject * obj0 = 0 ;
11120 char *kwnames[] = {
11121 (char *) "self", NULL
11122 };
11123
11124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11126 if (SWIG_arg_fail(1)) SWIG_fail;
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 result = (int)(arg1)->GetExitCode();
11130
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 {
11135 resultobj = SWIG_From_int((int)(result));
11136 }
11137 return resultobj;
11138 fail:
11139 return NULL;
11140 }
11141
11142
11143 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11144 PyObject *resultobj;
11145 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11146 int arg2 ;
11147 PyObject * obj0 = 0 ;
11148 PyObject * obj1 = 0 ;
11149 char *kwnames[] = {
11150 (char *) "self",(char *) "m_pid", NULL
11151 };
11152
11153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11155 if (SWIG_arg_fail(1)) SWIG_fail;
11156 {
11157 arg2 = (int)(SWIG_As_int(obj1));
11158 if (SWIG_arg_fail(2)) SWIG_fail;
11159 }
11160 if (arg1) (arg1)->m_pid = arg2;
11161
11162 Py_INCREF(Py_None); resultobj = Py_None;
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11170 PyObject *resultobj;
11171 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11172 int result;
11173 PyObject * obj0 = 0 ;
11174 char *kwnames[] = {
11175 (char *) "self", NULL
11176 };
11177
11178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11180 if (SWIG_arg_fail(1)) SWIG_fail;
11181 result = (int) ((arg1)->m_pid);
11182
11183 {
11184 resultobj = SWIG_From_int((int)(result));
11185 }
11186 return resultobj;
11187 fail:
11188 return NULL;
11189 }
11190
11191
11192 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj;
11194 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11195 int arg2 ;
11196 PyObject * obj0 = 0 ;
11197 PyObject * obj1 = 0 ;
11198 char *kwnames[] = {
11199 (char *) "self",(char *) "m_exitcode", NULL
11200 };
11201
11202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11204 if (SWIG_arg_fail(1)) SWIG_fail;
11205 {
11206 arg2 = (int)(SWIG_As_int(obj1));
11207 if (SWIG_arg_fail(2)) SWIG_fail;
11208 }
11209 if (arg1) (arg1)->m_exitcode = arg2;
11210
11211 Py_INCREF(Py_None); resultobj = Py_None;
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11219 PyObject *resultobj;
11220 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11221 int result;
11222 PyObject * obj0 = 0 ;
11223 char *kwnames[] = {
11224 (char *) "self", NULL
11225 };
11226
11227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11229 if (SWIG_arg_fail(1)) SWIG_fail;
11230 result = (int) ((arg1)->m_exitcode);
11231
11232 {
11233 resultobj = SWIG_From_int((int)(result));
11234 }
11235 return resultobj;
11236 fail:
11237 return NULL;
11238 }
11239
11240
11241 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11242 PyObject *obj;
11243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11244 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11245 Py_INCREF(obj);
11246 return Py_BuildValue((char *)"");
11247 }
11248 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj;
11250 wxString *arg1 = 0 ;
11251 int arg2 = (int) wxEXEC_ASYNC ;
11252 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11253 long result;
11254 bool temp1 = false ;
11255 PyObject * obj0 = 0 ;
11256 PyObject * obj1 = 0 ;
11257 PyObject * obj2 = 0 ;
11258 char *kwnames[] = {
11259 (char *) "command",(char *) "flags",(char *) "process", NULL
11260 };
11261
11262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11263 {
11264 arg1 = wxString_in_helper(obj0);
11265 if (arg1 == NULL) SWIG_fail;
11266 temp1 = true;
11267 }
11268 if (obj1) {
11269 {
11270 arg2 = (int)(SWIG_As_int(obj1));
11271 if (SWIG_arg_fail(2)) SWIG_fail;
11272 }
11273 }
11274 if (obj2) {
11275 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11276 if (SWIG_arg_fail(3)) SWIG_fail;
11277 }
11278 {
11279 if (!wxPyCheckForApp()) SWIG_fail;
11280 PyThreadState* __tstate = wxPyBeginAllowThreads();
11281 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11282
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 {
11287 resultobj = SWIG_From_long((long)(result));
11288 }
11289 {
11290 if (temp1)
11291 delete arg1;
11292 }
11293 return resultobj;
11294 fail:
11295 {
11296 if (temp1)
11297 delete arg1;
11298 }
11299 return NULL;
11300 }
11301
11302
11303 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11304 PyObject *resultobj;
11305 long arg1 ;
11306 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11307 wxKillError *arg3 = (wxKillError *) 0 ;
11308 int arg4 = (int) wxKILL_NOCHILDREN ;
11309 int result;
11310 wxKillError temp3 ;
11311 PyObject * obj0 = 0 ;
11312 PyObject * obj1 = 0 ;
11313 PyObject * obj2 = 0 ;
11314 char *kwnames[] = {
11315 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11316 };
11317
11318 {
11319 arg3 = &temp3;
11320 }
11321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11322 {
11323 arg1 = (long)(SWIG_As_long(obj0));
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 }
11326 if (obj1) {
11327 {
11328 arg2 = (wxSignal)(SWIG_As_int(obj1));
11329 if (SWIG_arg_fail(2)) SWIG_fail;
11330 }
11331 }
11332 if (obj2) {
11333 {
11334 arg4 = (int)(SWIG_As_int(obj2));
11335 if (SWIG_arg_fail(4)) SWIG_fail;
11336 }
11337 }
11338 {
11339 PyThreadState* __tstate = wxPyBeginAllowThreads();
11340 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11341
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 {
11346 resultobj = SWIG_From_int((int)(result));
11347 }
11348 {
11349 PyObject* o;
11350 o = PyInt_FromLong((long) (*arg3));
11351 resultobj = t_output_helper(resultobj, o);
11352 }
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj;
11361 int arg1 = (int) wxJOYSTICK1 ;
11362 wxJoystick *result;
11363 PyObject * obj0 = 0 ;
11364 char *kwnames[] = {
11365 (char *) "joystick", NULL
11366 };
11367
11368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11369 if (obj0) {
11370 {
11371 arg1 = (int)(SWIG_As_int(obj0));
11372 if (SWIG_arg_fail(1)) SWIG_fail;
11373 }
11374 }
11375 {
11376 if (!wxPyCheckForApp()) SWIG_fail;
11377 PyThreadState* __tstate = wxPyBeginAllowThreads();
11378 result = (wxJoystick *)new wxJoystick(arg1);
11379
11380 wxPyEndAllowThreads(__tstate);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj;
11392 wxJoystick *arg1 = (wxJoystick *) 0 ;
11393 PyObject * obj0 = 0 ;
11394 char *kwnames[] = {
11395 (char *) "self", NULL
11396 };
11397
11398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11400 if (SWIG_arg_fail(1)) SWIG_fail;
11401 {
11402 PyThreadState* __tstate = wxPyBeginAllowThreads();
11403 delete arg1;
11404
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 Py_INCREF(Py_None); resultobj = Py_None;
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj;
11417 wxJoystick *arg1 = (wxJoystick *) 0 ;
11418 wxPoint result;
11419 PyObject * obj0 = 0 ;
11420 char *kwnames[] = {
11421 (char *) "self", NULL
11422 };
11423
11424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11426 if (SWIG_arg_fail(1)) SWIG_fail;
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (arg1)->GetPosition();
11430
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 wxPoint * resultptr;
11436 resultptr = new wxPoint((wxPoint &)(result));
11437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11438 }
11439 return resultobj;
11440 fail:
11441 return NULL;
11442 }
11443
11444
11445 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11446 PyObject *resultobj;
11447 wxJoystick *arg1 = (wxJoystick *) 0 ;
11448 int result;
11449 PyObject * obj0 = 0 ;
11450 char *kwnames[] = {
11451 (char *) "self", NULL
11452 };
11453
11454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11456 if (SWIG_arg_fail(1)) SWIG_fail;
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 result = (int)(arg1)->GetZPosition();
11460
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = SWIG_From_int((int)(result));
11466 }
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj;
11475 wxJoystick *arg1 = (wxJoystick *) 0 ;
11476 int result;
11477 PyObject * obj0 = 0 ;
11478 char *kwnames[] = {
11479 (char *) "self", NULL
11480 };
11481
11482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (int)(arg1)->GetButtonState();
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 resultobj = SWIG_From_int((int)(result));
11494 }
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj;
11503 wxJoystick *arg1 = (wxJoystick *) 0 ;
11504 int result;
11505 PyObject * obj0 = 0 ;
11506 char *kwnames[] = {
11507 (char *) "self", NULL
11508 };
11509
11510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11512 if (SWIG_arg_fail(1)) SWIG_fail;
11513 {
11514 PyThreadState* __tstate = wxPyBeginAllowThreads();
11515 result = (int)(arg1)->GetPOVPosition();
11516
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 {
11521 resultobj = SWIG_From_int((int)(result));
11522 }
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj;
11531 wxJoystick *arg1 = (wxJoystick *) 0 ;
11532 int result;
11533 PyObject * obj0 = 0 ;
11534 char *kwnames[] = {
11535 (char *) "self", NULL
11536 };
11537
11538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11540 if (SWIG_arg_fail(1)) SWIG_fail;
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 result = (int)(arg1)->GetPOVCTSPosition();
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 {
11549 resultobj = SWIG_From_int((int)(result));
11550 }
11551 return resultobj;
11552 fail:
11553 return NULL;
11554 }
11555
11556
11557 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj;
11559 wxJoystick *arg1 = (wxJoystick *) 0 ;
11560 int result;
11561 PyObject * obj0 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 result = (int)(arg1)->GetRudderPosition();
11572
11573 wxPyEndAllowThreads(__tstate);
11574 if (PyErr_Occurred()) SWIG_fail;
11575 }
11576 {
11577 resultobj = SWIG_From_int((int)(result));
11578 }
11579 return resultobj;
11580 fail:
11581 return NULL;
11582 }
11583
11584
11585 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11586 PyObject *resultobj;
11587 wxJoystick *arg1 = (wxJoystick *) 0 ;
11588 int result;
11589 PyObject * obj0 = 0 ;
11590 char *kwnames[] = {
11591 (char *) "self", NULL
11592 };
11593
11594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11596 if (SWIG_arg_fail(1)) SWIG_fail;
11597 {
11598 PyThreadState* __tstate = wxPyBeginAllowThreads();
11599 result = (int)(arg1)->GetUPosition();
11600
11601 wxPyEndAllowThreads(__tstate);
11602 if (PyErr_Occurred()) SWIG_fail;
11603 }
11604 {
11605 resultobj = SWIG_From_int((int)(result));
11606 }
11607 return resultobj;
11608 fail:
11609 return NULL;
11610 }
11611
11612
11613 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj;
11615 wxJoystick *arg1 = (wxJoystick *) 0 ;
11616 int result;
11617 PyObject * obj0 = 0 ;
11618 char *kwnames[] = {
11619 (char *) "self", NULL
11620 };
11621
11622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11624 if (SWIG_arg_fail(1)) SWIG_fail;
11625 {
11626 PyThreadState* __tstate = wxPyBeginAllowThreads();
11627 result = (int)(arg1)->GetVPosition();
11628
11629 wxPyEndAllowThreads(__tstate);
11630 if (PyErr_Occurred()) SWIG_fail;
11631 }
11632 {
11633 resultobj = SWIG_From_int((int)(result));
11634 }
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj;
11643 wxJoystick *arg1 = (wxJoystick *) 0 ;
11644 int result;
11645 PyObject * obj0 = 0 ;
11646 char *kwnames[] = {
11647 (char *) "self", NULL
11648 };
11649
11650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11652 if (SWIG_arg_fail(1)) SWIG_fail;
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (int)(arg1)->GetMovementThreshold();
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = SWIG_From_int((int)(result));
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj;
11671 wxJoystick *arg1 = (wxJoystick *) 0 ;
11672 int arg2 ;
11673 PyObject * obj0 = 0 ;
11674 PyObject * obj1 = 0 ;
11675 char *kwnames[] = {
11676 (char *) "self",(char *) "threshold", NULL
11677 };
11678
11679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11681 if (SWIG_arg_fail(1)) SWIG_fail;
11682 {
11683 arg2 = (int)(SWIG_As_int(obj1));
11684 if (SWIG_arg_fail(2)) SWIG_fail;
11685 }
11686 {
11687 PyThreadState* __tstate = wxPyBeginAllowThreads();
11688 (arg1)->SetMovementThreshold(arg2);
11689
11690 wxPyEndAllowThreads(__tstate);
11691 if (PyErr_Occurred()) SWIG_fail;
11692 }
11693 Py_INCREF(Py_None); resultobj = Py_None;
11694 return resultobj;
11695 fail:
11696 return NULL;
11697 }
11698
11699
11700 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11701 PyObject *resultobj;
11702 wxJoystick *arg1 = (wxJoystick *) 0 ;
11703 bool result;
11704 PyObject * obj0 = 0 ;
11705 char *kwnames[] = {
11706 (char *) "self", NULL
11707 };
11708
11709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11711 if (SWIG_arg_fail(1)) SWIG_fail;
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (bool)(arg1)->IsOk();
11715
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 {
11720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj;
11730 wxJoystick *arg1 = (wxJoystick *) 0 ;
11731 int result;
11732 PyObject * obj0 = 0 ;
11733 char *kwnames[] = {
11734 (char *) "self", NULL
11735 };
11736
11737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11739 if (SWIG_arg_fail(1)) SWIG_fail;
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 result = (int)(arg1)->GetNumberJoysticks();
11743
11744 wxPyEndAllowThreads(__tstate);
11745 if (PyErr_Occurred()) SWIG_fail;
11746 }
11747 {
11748 resultobj = SWIG_From_int((int)(result));
11749 }
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11757 PyObject *resultobj;
11758 wxJoystick *arg1 = (wxJoystick *) 0 ;
11759 int result;
11760 PyObject * obj0 = 0 ;
11761 char *kwnames[] = {
11762 (char *) "self", NULL
11763 };
11764
11765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11767 if (SWIG_arg_fail(1)) SWIG_fail;
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 result = (int)(arg1)->GetManufacturerId();
11771
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 {
11776 resultobj = SWIG_From_int((int)(result));
11777 }
11778 return resultobj;
11779 fail:
11780 return NULL;
11781 }
11782
11783
11784 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11785 PyObject *resultobj;
11786 wxJoystick *arg1 = (wxJoystick *) 0 ;
11787 int result;
11788 PyObject * obj0 = 0 ;
11789 char *kwnames[] = {
11790 (char *) "self", NULL
11791 };
11792
11793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11795 if (SWIG_arg_fail(1)) SWIG_fail;
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (int)(arg1)->GetProductId();
11799
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 {
11804 resultobj = SWIG_From_int((int)(result));
11805 }
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj;
11814 wxJoystick *arg1 = (wxJoystick *) 0 ;
11815 wxString result;
11816 PyObject * obj0 = 0 ;
11817 char *kwnames[] = {
11818 (char *) "self", NULL
11819 };
11820
11821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11823 if (SWIG_arg_fail(1)) SWIG_fail;
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (arg1)->GetProductName();
11827
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 {
11832 #if wxUSE_UNICODE
11833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11834 #else
11835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11836 #endif
11837 }
11838 return resultobj;
11839 fail:
11840 return NULL;
11841 }
11842
11843
11844 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11845 PyObject *resultobj;
11846 wxJoystick *arg1 = (wxJoystick *) 0 ;
11847 int result;
11848 PyObject * obj0 = 0 ;
11849 char *kwnames[] = {
11850 (char *) "self", NULL
11851 };
11852
11853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11855 if (SWIG_arg_fail(1)) SWIG_fail;
11856 {
11857 PyThreadState* __tstate = wxPyBeginAllowThreads();
11858 result = (int)(arg1)->GetXMin();
11859
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 {
11864 resultobj = SWIG_From_int((int)(result));
11865 }
11866 return resultobj;
11867 fail:
11868 return NULL;
11869 }
11870
11871
11872 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11873 PyObject *resultobj;
11874 wxJoystick *arg1 = (wxJoystick *) 0 ;
11875 int result;
11876 PyObject * obj0 = 0 ;
11877 char *kwnames[] = {
11878 (char *) "self", NULL
11879 };
11880
11881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11883 if (SWIG_arg_fail(1)) SWIG_fail;
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (int)(arg1)->GetYMin();
11887
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 {
11892 resultobj = SWIG_From_int((int)(result));
11893 }
11894 return resultobj;
11895 fail:
11896 return NULL;
11897 }
11898
11899
11900 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11901 PyObject *resultobj;
11902 wxJoystick *arg1 = (wxJoystick *) 0 ;
11903 int result;
11904 PyObject * obj0 = 0 ;
11905 char *kwnames[] = {
11906 (char *) "self", NULL
11907 };
11908
11909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11911 if (SWIG_arg_fail(1)) SWIG_fail;
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 result = (int)(arg1)->GetZMin();
11915
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 {
11920 resultobj = SWIG_From_int((int)(result));
11921 }
11922 return resultobj;
11923 fail:
11924 return NULL;
11925 }
11926
11927
11928 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11929 PyObject *resultobj;
11930 wxJoystick *arg1 = (wxJoystick *) 0 ;
11931 int result;
11932 PyObject * obj0 = 0 ;
11933 char *kwnames[] = {
11934 (char *) "self", NULL
11935 };
11936
11937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11939 if (SWIG_arg_fail(1)) SWIG_fail;
11940 {
11941 PyThreadState* __tstate = wxPyBeginAllowThreads();
11942 result = (int)(arg1)->GetXMax();
11943
11944 wxPyEndAllowThreads(__tstate);
11945 if (PyErr_Occurred()) SWIG_fail;
11946 }
11947 {
11948 resultobj = SWIG_From_int((int)(result));
11949 }
11950 return resultobj;
11951 fail:
11952 return NULL;
11953 }
11954
11955
11956 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11957 PyObject *resultobj;
11958 wxJoystick *arg1 = (wxJoystick *) 0 ;
11959 int result;
11960 PyObject * obj0 = 0 ;
11961 char *kwnames[] = {
11962 (char *) "self", NULL
11963 };
11964
11965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11967 if (SWIG_arg_fail(1)) SWIG_fail;
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 result = (int)(arg1)->GetYMax();
11971
11972 wxPyEndAllowThreads(__tstate);
11973 if (PyErr_Occurred()) SWIG_fail;
11974 }
11975 {
11976 resultobj = SWIG_From_int((int)(result));
11977 }
11978 return resultobj;
11979 fail:
11980 return NULL;
11981 }
11982
11983
11984 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11985 PyObject *resultobj;
11986 wxJoystick *arg1 = (wxJoystick *) 0 ;
11987 int result;
11988 PyObject * obj0 = 0 ;
11989 char *kwnames[] = {
11990 (char *) "self", NULL
11991 };
11992
11993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
11994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11995 if (SWIG_arg_fail(1)) SWIG_fail;
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (int)(arg1)->GetZMax();
11999
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 {
12004 resultobj = SWIG_From_int((int)(result));
12005 }
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12013 PyObject *resultobj;
12014 wxJoystick *arg1 = (wxJoystick *) 0 ;
12015 int result;
12016 PyObject * obj0 = 0 ;
12017 char *kwnames[] = {
12018 (char *) "self", NULL
12019 };
12020
12021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12023 if (SWIG_arg_fail(1)) SWIG_fail;
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (int)(arg1)->GetNumberButtons();
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = SWIG_From_int((int)(result));
12033 }
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj;
12042 wxJoystick *arg1 = (wxJoystick *) 0 ;
12043 int result;
12044 PyObject * obj0 = 0 ;
12045 char *kwnames[] = {
12046 (char *) "self", NULL
12047 };
12048
12049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12051 if (SWIG_arg_fail(1)) SWIG_fail;
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 result = (int)(arg1)->GetNumberAxes();
12055
12056 wxPyEndAllowThreads(__tstate);
12057 if (PyErr_Occurred()) SWIG_fail;
12058 }
12059 {
12060 resultobj = SWIG_From_int((int)(result));
12061 }
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12069 PyObject *resultobj;
12070 wxJoystick *arg1 = (wxJoystick *) 0 ;
12071 int result;
12072 PyObject * obj0 = 0 ;
12073 char *kwnames[] = {
12074 (char *) "self", NULL
12075 };
12076
12077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12079 if (SWIG_arg_fail(1)) SWIG_fail;
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 result = (int)(arg1)->GetMaxButtons();
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 {
12088 resultobj = SWIG_From_int((int)(result));
12089 }
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12097 PyObject *resultobj;
12098 wxJoystick *arg1 = (wxJoystick *) 0 ;
12099 int result;
12100 PyObject * obj0 = 0 ;
12101 char *kwnames[] = {
12102 (char *) "self", NULL
12103 };
12104
12105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12107 if (SWIG_arg_fail(1)) SWIG_fail;
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 result = (int)(arg1)->GetMaxAxes();
12111
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 {
12116 resultobj = SWIG_From_int((int)(result));
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxJoystick *arg1 = (wxJoystick *) 0 ;
12127 int result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (int)(arg1)->GetPollingMin();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = SWIG_From_int((int)(result));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxJoystick *arg1 = (wxJoystick *) 0 ;
12155 int result;
12156 PyObject * obj0 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 result = (int)(arg1)->GetPollingMax();
12167
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 {
12172 resultobj = SWIG_From_int((int)(result));
12173 }
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj;
12182 wxJoystick *arg1 = (wxJoystick *) 0 ;
12183 int result;
12184 PyObject * obj0 = 0 ;
12185 char *kwnames[] = {
12186 (char *) "self", NULL
12187 };
12188
12189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12191 if (SWIG_arg_fail(1)) SWIG_fail;
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = (int)(arg1)->GetRudderMin();
12195
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 {
12200 resultobj = SWIG_From_int((int)(result));
12201 }
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj;
12210 wxJoystick *arg1 = (wxJoystick *) 0 ;
12211 int result;
12212 PyObject * obj0 = 0 ;
12213 char *kwnames[] = {
12214 (char *) "self", NULL
12215 };
12216
12217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12219 if (SWIG_arg_fail(1)) SWIG_fail;
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (int)(arg1)->GetRudderMax();
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = SWIG_From_int((int)(result));
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj;
12238 wxJoystick *arg1 = (wxJoystick *) 0 ;
12239 int result;
12240 PyObject * obj0 = 0 ;
12241 char *kwnames[] = {
12242 (char *) "self", NULL
12243 };
12244
12245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12247 if (SWIG_arg_fail(1)) SWIG_fail;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (int)(arg1)->GetUMin();
12251
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 resultobj = SWIG_From_int((int)(result));
12257 }
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj;
12266 wxJoystick *arg1 = (wxJoystick *) 0 ;
12267 int result;
12268 PyObject * obj0 = 0 ;
12269 char *kwnames[] = {
12270 (char *) "self", NULL
12271 };
12272
12273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (int)(arg1)->GetUMax();
12279
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 {
12284 resultobj = SWIG_From_int((int)(result));
12285 }
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12293 PyObject *resultobj;
12294 wxJoystick *arg1 = (wxJoystick *) 0 ;
12295 int result;
12296 PyObject * obj0 = 0 ;
12297 char *kwnames[] = {
12298 (char *) "self", NULL
12299 };
12300
12301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12303 if (SWIG_arg_fail(1)) SWIG_fail;
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 result = (int)(arg1)->GetVMin();
12307
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 {
12312 resultobj = SWIG_From_int((int)(result));
12313 }
12314 return resultobj;
12315 fail:
12316 return NULL;
12317 }
12318
12319
12320 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12321 PyObject *resultobj;
12322 wxJoystick *arg1 = (wxJoystick *) 0 ;
12323 int result;
12324 PyObject * obj0 = 0 ;
12325 char *kwnames[] = {
12326 (char *) "self", NULL
12327 };
12328
12329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12331 if (SWIG_arg_fail(1)) SWIG_fail;
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 result = (int)(arg1)->GetVMax();
12335
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 {
12340 resultobj = SWIG_From_int((int)(result));
12341 }
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj;
12350 wxJoystick *arg1 = (wxJoystick *) 0 ;
12351 bool result;
12352 PyObject * obj0 = 0 ;
12353 char *kwnames[] = {
12354 (char *) "self", NULL
12355 };
12356
12357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12359 if (SWIG_arg_fail(1)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (bool)(arg1)->HasRudder();
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxJoystick *arg1 = (wxJoystick *) 0 ;
12379 bool result;
12380 PyObject * obj0 = 0 ;
12381 char *kwnames[] = {
12382 (char *) "self", NULL
12383 };
12384
12385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12387 if (SWIG_arg_fail(1)) SWIG_fail;
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (bool)(arg1)->HasZ();
12391
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12405 PyObject *resultobj;
12406 wxJoystick *arg1 = (wxJoystick *) 0 ;
12407 bool result;
12408 PyObject * obj0 = 0 ;
12409 char *kwnames[] = {
12410 (char *) "self", NULL
12411 };
12412
12413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12415 if (SWIG_arg_fail(1)) SWIG_fail;
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (bool)(arg1)->HasU();
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj;
12434 wxJoystick *arg1 = (wxJoystick *) 0 ;
12435 bool result;
12436 PyObject * obj0 = 0 ;
12437 char *kwnames[] = {
12438 (char *) "self", NULL
12439 };
12440
12441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12443 if (SWIG_arg_fail(1)) SWIG_fail;
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (bool)(arg1)->HasV();
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12453 }
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12461 PyObject *resultobj;
12462 wxJoystick *arg1 = (wxJoystick *) 0 ;
12463 bool result;
12464 PyObject * obj0 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (bool)(arg1)->HasPOV();
12475
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj;
12490 wxJoystick *arg1 = (wxJoystick *) 0 ;
12491 bool result;
12492 PyObject * obj0 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (bool)(arg1)->HasPOV4Dir();
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12509 }
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj;
12518 wxJoystick *arg1 = (wxJoystick *) 0 ;
12519 bool result;
12520 PyObject * obj0 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (bool)(arg1)->HasPOVCTS();
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12537 }
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxJoystick *arg1 = (wxJoystick *) 0 ;
12547 wxWindow *arg2 = (wxWindow *) 0 ;
12548 int arg3 = (int) 0 ;
12549 bool result;
12550 PyObject * obj0 = 0 ;
12551 PyObject * obj1 = 0 ;
12552 PyObject * obj2 = 0 ;
12553 char *kwnames[] = {
12554 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12555 };
12556
12557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12559 if (SWIG_arg_fail(1)) SWIG_fail;
12560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12561 if (SWIG_arg_fail(2)) SWIG_fail;
12562 if (obj2) {
12563 {
12564 arg3 = (int)(SWIG_As_int(obj2));
12565 if (SWIG_arg_fail(3)) SWIG_fail;
12566 }
12567 }
12568 {
12569 PyThreadState* __tstate = wxPyBeginAllowThreads();
12570 result = (bool)(arg1)->SetCapture(arg2,arg3);
12571
12572 wxPyEndAllowThreads(__tstate);
12573 if (PyErr_Occurred()) SWIG_fail;
12574 }
12575 {
12576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12577 }
12578 return resultobj;
12579 fail:
12580 return NULL;
12581 }
12582
12583
12584 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12585 PyObject *resultobj;
12586 wxJoystick *arg1 = (wxJoystick *) 0 ;
12587 bool result;
12588 PyObject * obj0 = 0 ;
12589 char *kwnames[] = {
12590 (char *) "self", NULL
12591 };
12592
12593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12595 if (SWIG_arg_fail(1)) SWIG_fail;
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 result = (bool)(arg1)->ReleaseCapture();
12599
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 {
12604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12605 }
12606 return resultobj;
12607 fail:
12608 return NULL;
12609 }
12610
12611
12612 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12613 PyObject *obj;
12614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12615 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12616 Py_INCREF(obj);
12617 return Py_BuildValue((char *)"");
12618 }
12619 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj;
12621 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12622 int arg2 = (int) 0 ;
12623 int arg3 = (int) wxJOYSTICK1 ;
12624 int arg4 = (int) 0 ;
12625 wxJoystickEvent *result;
12626 PyObject * obj0 = 0 ;
12627 PyObject * obj1 = 0 ;
12628 PyObject * obj2 = 0 ;
12629 PyObject * obj3 = 0 ;
12630 char *kwnames[] = {
12631 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12632 };
12633
12634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12635 if (obj0) {
12636 {
12637 arg1 = (wxEventType)(SWIG_As_int(obj0));
12638 if (SWIG_arg_fail(1)) SWIG_fail;
12639 }
12640 }
12641 if (obj1) {
12642 {
12643 arg2 = (int)(SWIG_As_int(obj1));
12644 if (SWIG_arg_fail(2)) SWIG_fail;
12645 }
12646 }
12647 if (obj2) {
12648 {
12649 arg3 = (int)(SWIG_As_int(obj2));
12650 if (SWIG_arg_fail(3)) SWIG_fail;
12651 }
12652 }
12653 if (obj3) {
12654 {
12655 arg4 = (int)(SWIG_As_int(obj3));
12656 if (SWIG_arg_fail(4)) SWIG_fail;
12657 }
12658 }
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12667 return resultobj;
12668 fail:
12669 return NULL;
12670 }
12671
12672
12673 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12674 PyObject *resultobj;
12675 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12676 wxPoint result;
12677 PyObject * obj0 = 0 ;
12678 char *kwnames[] = {
12679 (char *) "self", NULL
12680 };
12681
12682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12684 if (SWIG_arg_fail(1)) SWIG_fail;
12685 {
12686 PyThreadState* __tstate = wxPyBeginAllowThreads();
12687 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12688
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 {
12693 wxPoint * resultptr;
12694 resultptr = new wxPoint((wxPoint &)(result));
12695 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12696 }
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj;
12705 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12706 int result;
12707 PyObject * obj0 = 0 ;
12708 char *kwnames[] = {
12709 (char *) "self", NULL
12710 };
12711
12712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12714 if (SWIG_arg_fail(1)) SWIG_fail;
12715 {
12716 PyThreadState* __tstate = wxPyBeginAllowThreads();
12717 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12718
12719 wxPyEndAllowThreads(__tstate);
12720 if (PyErr_Occurred()) SWIG_fail;
12721 }
12722 {
12723 resultobj = SWIG_From_int((int)(result));
12724 }
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12732 PyObject *resultobj;
12733 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12734 int result;
12735 PyObject * obj0 = 0 ;
12736 char *kwnames[] = {
12737 (char *) "self", NULL
12738 };
12739
12740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12742 if (SWIG_arg_fail(1)) SWIG_fail;
12743 {
12744 PyThreadState* __tstate = wxPyBeginAllowThreads();
12745 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12746
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 {
12751 resultobj = SWIG_From_int((int)(result));
12752 }
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj;
12761 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12762 int result;
12763 PyObject * obj0 = 0 ;
12764 char *kwnames[] = {
12765 (char *) "self", NULL
12766 };
12767
12768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12770 if (SWIG_arg_fail(1)) SWIG_fail;
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12774
12775 wxPyEndAllowThreads(__tstate);
12776 if (PyErr_Occurred()) SWIG_fail;
12777 }
12778 {
12779 resultobj = SWIG_From_int((int)(result));
12780 }
12781 return resultobj;
12782 fail:
12783 return NULL;
12784 }
12785
12786
12787 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12788 PyObject *resultobj;
12789 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12790 int result;
12791 PyObject * obj0 = 0 ;
12792 char *kwnames[] = {
12793 (char *) "self", NULL
12794 };
12795
12796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12798 if (SWIG_arg_fail(1)) SWIG_fail;
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12802
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 {
12807 resultobj = SWIG_From_int((int)(result));
12808 }
12809 return resultobj;
12810 fail:
12811 return NULL;
12812 }
12813
12814
12815 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12816 PyObject *resultobj;
12817 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12818 int arg2 ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 char *kwnames[] = {
12822 (char *) "self",(char *) "stick", NULL
12823 };
12824
12825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12827 if (SWIG_arg_fail(1)) SWIG_fail;
12828 {
12829 arg2 = (int)(SWIG_As_int(obj1));
12830 if (SWIG_arg_fail(2)) SWIG_fail;
12831 }
12832 {
12833 PyThreadState* __tstate = wxPyBeginAllowThreads();
12834 (arg1)->SetJoystick(arg2);
12835
12836 wxPyEndAllowThreads(__tstate);
12837 if (PyErr_Occurred()) SWIG_fail;
12838 }
12839 Py_INCREF(Py_None); resultobj = Py_None;
12840 return resultobj;
12841 fail:
12842 return NULL;
12843 }
12844
12845
12846 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12847 PyObject *resultobj;
12848 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12849 int arg2 ;
12850 PyObject * obj0 = 0 ;
12851 PyObject * obj1 = 0 ;
12852 char *kwnames[] = {
12853 (char *) "self",(char *) "state", NULL
12854 };
12855
12856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12858 if (SWIG_arg_fail(1)) SWIG_fail;
12859 {
12860 arg2 = (int)(SWIG_As_int(obj1));
12861 if (SWIG_arg_fail(2)) SWIG_fail;
12862 }
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 (arg1)->SetButtonState(arg2);
12866
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 Py_INCREF(Py_None); resultobj = Py_None;
12871 return resultobj;
12872 fail:
12873 return NULL;
12874 }
12875
12876
12877 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12878 PyObject *resultobj;
12879 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12880 int arg2 ;
12881 PyObject * obj0 = 0 ;
12882 PyObject * obj1 = 0 ;
12883 char *kwnames[] = {
12884 (char *) "self",(char *) "change", NULL
12885 };
12886
12887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12889 if (SWIG_arg_fail(1)) SWIG_fail;
12890 {
12891 arg2 = (int)(SWIG_As_int(obj1));
12892 if (SWIG_arg_fail(2)) SWIG_fail;
12893 }
12894 {
12895 PyThreadState* __tstate = wxPyBeginAllowThreads();
12896 (arg1)->SetButtonChange(arg2);
12897
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 Py_INCREF(Py_None); resultobj = Py_None;
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12909 PyObject *resultobj;
12910 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12911 wxPoint *arg2 = 0 ;
12912 wxPoint temp2 ;
12913 PyObject * obj0 = 0 ;
12914 PyObject * obj1 = 0 ;
12915 char *kwnames[] = {
12916 (char *) "self",(char *) "pos", NULL
12917 };
12918
12919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12921 if (SWIG_arg_fail(1)) SWIG_fail;
12922 {
12923 arg2 = &temp2;
12924 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12925 }
12926 {
12927 PyThreadState* __tstate = wxPyBeginAllowThreads();
12928 (arg1)->SetPosition((wxPoint const &)*arg2);
12929
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 Py_INCREF(Py_None); resultobj = Py_None;
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12941 PyObject *resultobj;
12942 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12943 int arg2 ;
12944 PyObject * obj0 = 0 ;
12945 PyObject * obj1 = 0 ;
12946 char *kwnames[] = {
12947 (char *) "self",(char *) "zPos", NULL
12948 };
12949
12950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12952 if (SWIG_arg_fail(1)) SWIG_fail;
12953 {
12954 arg2 = (int)(SWIG_As_int(obj1));
12955 if (SWIG_arg_fail(2)) SWIG_fail;
12956 }
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 (arg1)->SetZPosition(arg2);
12960
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 Py_INCREF(Py_None); resultobj = Py_None;
12965 return resultobj;
12966 fail:
12967 return NULL;
12968 }
12969
12970
12971 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12972 PyObject *resultobj;
12973 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12974 bool result;
12975 PyObject * obj0 = 0 ;
12976 char *kwnames[] = {
12977 (char *) "self", NULL
12978 };
12979
12980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12982 if (SWIG_arg_fail(1)) SWIG_fail;
12983 {
12984 PyThreadState* __tstate = wxPyBeginAllowThreads();
12985 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
12986
12987 wxPyEndAllowThreads(__tstate);
12988 if (PyErr_Occurred()) SWIG_fail;
12989 }
12990 {
12991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12992 }
12993 return resultobj;
12994 fail:
12995 return NULL;
12996 }
12997
12998
12999 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13000 PyObject *resultobj;
13001 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13002 bool result;
13003 PyObject * obj0 = 0 ;
13004 char *kwnames[] = {
13005 (char *) "self", NULL
13006 };
13007
13008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13014
13015 wxPyEndAllowThreads(__tstate);
13016 if (PyErr_Occurred()) SWIG_fail;
13017 }
13018 {
13019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13020 }
13021 return resultobj;
13022 fail:
13023 return NULL;
13024 }
13025
13026
13027 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13028 PyObject *resultobj;
13029 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13030 bool result;
13031 PyObject * obj0 = 0 ;
13032 char *kwnames[] = {
13033 (char *) "self", NULL
13034 };
13035
13036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13038 if (SWIG_arg_fail(1)) SWIG_fail;
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 {
13047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13048 }
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj;
13057 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13058 int arg2 = (int) wxJOY_BUTTON_ANY ;
13059 bool result;
13060 PyObject * obj0 = 0 ;
13061 PyObject * obj1 = 0 ;
13062 char *kwnames[] = {
13063 (char *) "self",(char *) "but", NULL
13064 };
13065
13066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13068 if (SWIG_arg_fail(1)) SWIG_fail;
13069 if (obj1) {
13070 {
13071 arg2 = (int)(SWIG_As_int(obj1));
13072 if (SWIG_arg_fail(2)) SWIG_fail;
13073 }
13074 }
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13078
13079 wxPyEndAllowThreads(__tstate);
13080 if (PyErr_Occurred()) SWIG_fail;
13081 }
13082 {
13083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13084 }
13085 return resultobj;
13086 fail:
13087 return NULL;
13088 }
13089
13090
13091 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13092 PyObject *resultobj;
13093 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13094 int arg2 = (int) wxJOY_BUTTON_ANY ;
13095 bool result;
13096 PyObject * obj0 = 0 ;
13097 PyObject * obj1 = 0 ;
13098 char *kwnames[] = {
13099 (char *) "self",(char *) "but", NULL
13100 };
13101
13102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13104 if (SWIG_arg_fail(1)) SWIG_fail;
13105 if (obj1) {
13106 {
13107 arg2 = (int)(SWIG_As_int(obj1));
13108 if (SWIG_arg_fail(2)) SWIG_fail;
13109 }
13110 }
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13120 }
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj;
13129 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13130 int arg2 = (int) wxJOY_BUTTON_ANY ;
13131 bool result;
13132 PyObject * obj0 = 0 ;
13133 PyObject * obj1 = 0 ;
13134 char *kwnames[] = {
13135 (char *) "self",(char *) "but", NULL
13136 };
13137
13138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13140 if (SWIG_arg_fail(1)) SWIG_fail;
13141 if (obj1) {
13142 {
13143 arg2 = (int)(SWIG_As_int(obj1));
13144 if (SWIG_arg_fail(2)) SWIG_fail;
13145 }
13146 }
13147 {
13148 PyThreadState* __tstate = wxPyBeginAllowThreads();
13149 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13150
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 {
13155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13156 }
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13164 PyObject *obj;
13165 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13166 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13167 Py_INCREF(obj);
13168 return Py_BuildValue((char *)"");
13169 }
13170 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13171 PyObject *resultobj;
13172 wxString const &arg1_defvalue = wxPyEmptyString ;
13173 wxString *arg1 = (wxString *) &arg1_defvalue ;
13174 wxSound *result;
13175 bool temp1 = false ;
13176 PyObject * obj0 = 0 ;
13177 char *kwnames[] = {
13178 (char *) "fileName", NULL
13179 };
13180
13181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13182 if (obj0) {
13183 {
13184 arg1 = wxString_in_helper(obj0);
13185 if (arg1 == NULL) SWIG_fail;
13186 temp1 = true;
13187 }
13188 }
13189 {
13190 if (!wxPyCheckForApp()) SWIG_fail;
13191 PyThreadState* __tstate = wxPyBeginAllowThreads();
13192 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13193
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13198 {
13199 if (temp1)
13200 delete arg1;
13201 }
13202 return resultobj;
13203 fail:
13204 {
13205 if (temp1)
13206 delete arg1;
13207 }
13208 return NULL;
13209 }
13210
13211
13212 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13213 PyObject *resultobj;
13214 PyObject *arg1 = (PyObject *) 0 ;
13215 wxSound *result;
13216 PyObject * obj0 = 0 ;
13217 char *kwnames[] = {
13218 (char *) "data", NULL
13219 };
13220
13221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13222 arg1 = obj0;
13223 {
13224 if (!wxPyCheckForApp()) SWIG_fail;
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (wxSound *)new_wxSound(arg1);
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj;
13240 wxSound *arg1 = (wxSound *) 0 ;
13241 PyObject * obj0 = 0 ;
13242 char *kwnames[] = {
13243 (char *) "self", NULL
13244 };
13245
13246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13248 if (SWIG_arg_fail(1)) SWIG_fail;
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 delete arg1;
13252
13253 wxPyEndAllowThreads(__tstate);
13254 if (PyErr_Occurred()) SWIG_fail;
13255 }
13256 Py_INCREF(Py_None); resultobj = Py_None;
13257 return resultobj;
13258 fail:
13259 return NULL;
13260 }
13261
13262
13263 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13264 PyObject *resultobj;
13265 wxSound *arg1 = (wxSound *) 0 ;
13266 wxString *arg2 = 0 ;
13267 bool result;
13268 bool temp2 = false ;
13269 PyObject * obj0 = 0 ;
13270 PyObject * obj1 = 0 ;
13271 char *kwnames[] = {
13272 (char *) "self",(char *) "fileName", NULL
13273 };
13274
13275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13277 if (SWIG_arg_fail(1)) SWIG_fail;
13278 {
13279 arg2 = wxString_in_helper(obj1);
13280 if (arg2 == NULL) SWIG_fail;
13281 temp2 = true;
13282 }
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = (bool)(arg1)->Create((wxString const &)*arg2);
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 {
13291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13292 }
13293 {
13294 if (temp2)
13295 delete arg2;
13296 }
13297 return resultobj;
13298 fail:
13299 {
13300 if (temp2)
13301 delete arg2;
13302 }
13303 return NULL;
13304 }
13305
13306
13307 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13308 PyObject *resultobj;
13309 wxSound *arg1 = (wxSound *) 0 ;
13310 PyObject *arg2 = (PyObject *) 0 ;
13311 bool result;
13312 PyObject * obj0 = 0 ;
13313 PyObject * obj1 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self",(char *) "data", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 arg2 = obj1;
13322 {
13323 PyThreadState* __tstate = wxPyBeginAllowThreads();
13324 result = (bool)wxSound_CreateFromData(arg1,arg2);
13325
13326 wxPyEndAllowThreads(__tstate);
13327 if (PyErr_Occurred()) SWIG_fail;
13328 }
13329 {
13330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13331 }
13332 return resultobj;
13333 fail:
13334 return NULL;
13335 }
13336
13337
13338 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj;
13340 wxSound *arg1 = (wxSound *) 0 ;
13341 bool result;
13342 PyObject * obj0 = 0 ;
13343 char *kwnames[] = {
13344 (char *) "self", NULL
13345 };
13346
13347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13349 if (SWIG_arg_fail(1)) SWIG_fail;
13350 {
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 result = (bool)(arg1)->IsOk();
13353
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 {
13358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13359 }
13360 return resultobj;
13361 fail:
13362 return NULL;
13363 }
13364
13365
13366 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13367 PyObject *resultobj;
13368 wxSound *arg1 = (wxSound *) 0 ;
13369 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13370 bool result;
13371 PyObject * obj0 = 0 ;
13372 PyObject * obj1 = 0 ;
13373 char *kwnames[] = {
13374 (char *) "self",(char *) "flags", NULL
13375 };
13376
13377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13379 if (SWIG_arg_fail(1)) SWIG_fail;
13380 if (obj1) {
13381 {
13382 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13383 if (SWIG_arg_fail(2)) SWIG_fail;
13384 }
13385 }
13386 {
13387 if (!wxPyCheckForApp()) SWIG_fail;
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 result = (bool)((wxSound const *)arg1)->Play(arg2);
13390
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 {
13395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13396 }
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj;
13405 wxString *arg1 = 0 ;
13406 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13407 bool result;
13408 bool temp1 = false ;
13409 PyObject * obj0 = 0 ;
13410 PyObject * obj1 = 0 ;
13411 char *kwnames[] = {
13412 (char *) "filename",(char *) "flags", NULL
13413 };
13414
13415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13416 {
13417 arg1 = wxString_in_helper(obj0);
13418 if (arg1 == NULL) SWIG_fail;
13419 temp1 = true;
13420 }
13421 if (obj1) {
13422 {
13423 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13424 if (SWIG_arg_fail(2)) SWIG_fail;
13425 }
13426 }
13427 {
13428 if (!wxPyCheckForApp()) SWIG_fail;
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13431
13432 wxPyEndAllowThreads(__tstate);
13433 if (PyErr_Occurred()) SWIG_fail;
13434 }
13435 {
13436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13437 }
13438 {
13439 if (temp1)
13440 delete arg1;
13441 }
13442 return resultobj;
13443 fail:
13444 {
13445 if (temp1)
13446 delete arg1;
13447 }
13448 return NULL;
13449 }
13450
13451
13452 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj;
13454 char *kwnames[] = {
13455 NULL
13456 };
13457
13458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13459 {
13460 if (!wxPyCheckForApp()) SWIG_fail;
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 wxSound::Stop();
13463
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 Py_INCREF(Py_None); resultobj = Py_None;
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13475 PyObject *obj;
13476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13477 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13478 Py_INCREF(obj);
13479 return Py_BuildValue((char *)"");
13480 }
13481 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj;
13483 wxString *arg1 = 0 ;
13484 wxString *arg2 = 0 ;
13485 wxString *arg3 = 0 ;
13486 wxString *arg4 = 0 ;
13487 wxFileTypeInfo *result;
13488 bool temp1 = false ;
13489 bool temp2 = false ;
13490 bool temp3 = false ;
13491 bool temp4 = false ;
13492 PyObject * obj0 = 0 ;
13493 PyObject * obj1 = 0 ;
13494 PyObject * obj2 = 0 ;
13495 PyObject * obj3 = 0 ;
13496 char *kwnames[] = {
13497 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13498 };
13499
13500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13501 {
13502 arg1 = wxString_in_helper(obj0);
13503 if (arg1 == NULL) SWIG_fail;
13504 temp1 = true;
13505 }
13506 {
13507 arg2 = wxString_in_helper(obj1);
13508 if (arg2 == NULL) SWIG_fail;
13509 temp2 = true;
13510 }
13511 {
13512 arg3 = wxString_in_helper(obj2);
13513 if (arg3 == NULL) SWIG_fail;
13514 temp3 = true;
13515 }
13516 {
13517 arg4 = wxString_in_helper(obj3);
13518 if (arg4 == NULL) SWIG_fail;
13519 temp4 = true;
13520 }
13521 {
13522 PyThreadState* __tstate = wxPyBeginAllowThreads();
13523 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13524
13525 wxPyEndAllowThreads(__tstate);
13526 if (PyErr_Occurred()) SWIG_fail;
13527 }
13528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13529 {
13530 if (temp1)
13531 delete arg1;
13532 }
13533 {
13534 if (temp2)
13535 delete arg2;
13536 }
13537 {
13538 if (temp3)
13539 delete arg3;
13540 }
13541 {
13542 if (temp4)
13543 delete arg4;
13544 }
13545 return resultobj;
13546 fail:
13547 {
13548 if (temp1)
13549 delete arg1;
13550 }
13551 {
13552 if (temp2)
13553 delete arg2;
13554 }
13555 {
13556 if (temp3)
13557 delete arg3;
13558 }
13559 {
13560 if (temp4)
13561 delete arg4;
13562 }
13563 return NULL;
13564 }
13565
13566
13567 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13568 PyObject *resultobj;
13569 wxArrayString *arg1 = 0 ;
13570 wxFileTypeInfo *result;
13571 bool temp1 = false ;
13572 PyObject * obj0 = 0 ;
13573 char *kwnames[] = {
13574 (char *) "sArray", NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13578 {
13579 if (! PySequence_Check(obj0)) {
13580 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13581 SWIG_fail;
13582 }
13583 arg1 = new wxArrayString;
13584 temp1 = true;
13585 int i, len=PySequence_Length(obj0);
13586 for (i=0; i<len; i++) {
13587 PyObject* item = PySequence_GetItem(obj0, i);
13588 #if wxUSE_UNICODE
13589 PyObject* str = PyObject_Unicode(item);
13590 #else
13591 PyObject* str = PyObject_Str(item);
13592 #endif
13593 if (PyErr_Occurred()) SWIG_fail;
13594 arg1->Add(Py2wxString(str));
13595 Py_DECREF(item);
13596 Py_DECREF(str);
13597 }
13598 }
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13602
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13607 {
13608 if (temp1) delete arg1;
13609 }
13610 return resultobj;
13611 fail:
13612 {
13613 if (temp1) delete arg1;
13614 }
13615 return NULL;
13616 }
13617
13618
13619 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj;
13621 wxFileTypeInfo *result;
13622 char *kwnames[] = {
13623 NULL
13624 };
13625
13626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13630
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13635 return resultobj;
13636 fail:
13637 return NULL;
13638 }
13639
13640
13641 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj;
13643 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13644 bool result;
13645 PyObject * obj0 = 0 ;
13646 char *kwnames[] = {
13647 (char *) "self", NULL
13648 };
13649
13650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13652 if (SWIG_arg_fail(1)) SWIG_fail;
13653 {
13654 PyThreadState* __tstate = wxPyBeginAllowThreads();
13655 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13656
13657 wxPyEndAllowThreads(__tstate);
13658 if (PyErr_Occurred()) SWIG_fail;
13659 }
13660 {
13661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13662 }
13663 return resultobj;
13664 fail:
13665 return NULL;
13666 }
13667
13668
13669 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13670 PyObject *resultobj;
13671 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13672 wxString *arg2 = 0 ;
13673 int arg3 = (int) 0 ;
13674 bool temp2 = false ;
13675 PyObject * obj0 = 0 ;
13676 PyObject * obj1 = 0 ;
13677 PyObject * obj2 = 0 ;
13678 char *kwnames[] = {
13679 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13680 };
13681
13682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13684 if (SWIG_arg_fail(1)) SWIG_fail;
13685 {
13686 arg2 = wxString_in_helper(obj1);
13687 if (arg2 == NULL) SWIG_fail;
13688 temp2 = true;
13689 }
13690 if (obj2) {
13691 {
13692 arg3 = (int)(SWIG_As_int(obj2));
13693 if (SWIG_arg_fail(3)) SWIG_fail;
13694 }
13695 }
13696 {
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13699
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 Py_INCREF(Py_None); resultobj = Py_None;
13704 {
13705 if (temp2)
13706 delete arg2;
13707 }
13708 return resultobj;
13709 fail:
13710 {
13711 if (temp2)
13712 delete arg2;
13713 }
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13721 wxString *arg2 = 0 ;
13722 bool temp2 = false ;
13723 PyObject * obj0 = 0 ;
13724 PyObject * obj1 = 0 ;
13725 char *kwnames[] = {
13726 (char *) "self",(char *) "shortDesc", NULL
13727 };
13728
13729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13731 if (SWIG_arg_fail(1)) SWIG_fail;
13732 {
13733 arg2 = wxString_in_helper(obj1);
13734 if (arg2 == NULL) SWIG_fail;
13735 temp2 = true;
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 (arg1)->SetShortDesc((wxString const &)*arg2);
13740
13741 wxPyEndAllowThreads(__tstate);
13742 if (PyErr_Occurred()) SWIG_fail;
13743 }
13744 Py_INCREF(Py_None); resultobj = Py_None;
13745 {
13746 if (temp2)
13747 delete arg2;
13748 }
13749 return resultobj;
13750 fail:
13751 {
13752 if (temp2)
13753 delete arg2;
13754 }
13755 return NULL;
13756 }
13757
13758
13759 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj;
13761 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13762 wxString *result;
13763 PyObject * obj0 = 0 ;
13764 char *kwnames[] = {
13765 (char *) "self", NULL
13766 };
13767
13768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13770 if (SWIG_arg_fail(1)) SWIG_fail;
13771 {
13772 PyThreadState* __tstate = wxPyBeginAllowThreads();
13773 {
13774 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13775 result = (wxString *) &_result_ref;
13776 }
13777
13778 wxPyEndAllowThreads(__tstate);
13779 if (PyErr_Occurred()) SWIG_fail;
13780 }
13781 {
13782 #if wxUSE_UNICODE
13783 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13784 #else
13785 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13786 #endif
13787 }
13788 return resultobj;
13789 fail:
13790 return NULL;
13791 }
13792
13793
13794 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13795 PyObject *resultobj;
13796 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13797 wxString *result;
13798 PyObject * obj0 = 0 ;
13799 char *kwnames[] = {
13800 (char *) "self", NULL
13801 };
13802
13803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13805 if (SWIG_arg_fail(1)) SWIG_fail;
13806 {
13807 PyThreadState* __tstate = wxPyBeginAllowThreads();
13808 {
13809 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13810 result = (wxString *) &_result_ref;
13811 }
13812
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 {
13817 #if wxUSE_UNICODE
13818 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13819 #else
13820 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13821 #endif
13822 }
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj;
13831 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13832 wxString *result;
13833 PyObject * obj0 = 0 ;
13834 char *kwnames[] = {
13835 (char *) "self", NULL
13836 };
13837
13838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13840 if (SWIG_arg_fail(1)) SWIG_fail;
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 {
13844 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13845 result = (wxString *) &_result_ref;
13846 }
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 {
13852 #if wxUSE_UNICODE
13853 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13854 #else
13855 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13856 #endif
13857 }
13858 return resultobj;
13859 fail:
13860 return NULL;
13861 }
13862
13863
13864 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13865 PyObject *resultobj;
13866 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13867 wxString *result;
13868 PyObject * obj0 = 0 ;
13869 char *kwnames[] = {
13870 (char *) "self", NULL
13871 };
13872
13873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13875 if (SWIG_arg_fail(1)) SWIG_fail;
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 {
13879 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13880 result = (wxString *) &_result_ref;
13881 }
13882
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 {
13887 #if wxUSE_UNICODE
13888 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13889 #else
13890 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13891 #endif
13892 }
13893 return resultobj;
13894 fail:
13895 return NULL;
13896 }
13897
13898
13899 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13900 PyObject *resultobj;
13901 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13902 wxString *result;
13903 PyObject * obj0 = 0 ;
13904 char *kwnames[] = {
13905 (char *) "self", NULL
13906 };
13907
13908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13910 if (SWIG_arg_fail(1)) SWIG_fail;
13911 {
13912 PyThreadState* __tstate = wxPyBeginAllowThreads();
13913 {
13914 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13915 result = (wxString *) &_result_ref;
13916 }
13917
13918 wxPyEndAllowThreads(__tstate);
13919 if (PyErr_Occurred()) SWIG_fail;
13920 }
13921 {
13922 #if wxUSE_UNICODE
13923 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13924 #else
13925 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13926 #endif
13927 }
13928 return resultobj;
13929 fail:
13930 return NULL;
13931 }
13932
13933
13934 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13935 PyObject *resultobj;
13936 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13937 wxArrayString *result;
13938 PyObject * obj0 = 0 ;
13939 char *kwnames[] = {
13940 (char *) "self", NULL
13941 };
13942
13943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13945 if (SWIG_arg_fail(1)) SWIG_fail;
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 {
13949 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13950 result = (wxArrayString *) &_result_ref;
13951 }
13952
13953 wxPyEndAllowThreads(__tstate);
13954 if (PyErr_Occurred()) SWIG_fail;
13955 }
13956 {
13957 resultobj = wxArrayString2PyList_helper(*result);
13958 }
13959 return resultobj;
13960 fail:
13961 return NULL;
13962 }
13963
13964
13965 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13966 PyObject *resultobj;
13967 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13968 int result;
13969 PyObject * obj0 = 0 ;
13970 char *kwnames[] = {
13971 (char *) "self", NULL
13972 };
13973
13974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13976 if (SWIG_arg_fail(1)) SWIG_fail;
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 {
13985 resultobj = SWIG_From_int((int)(result));
13986 }
13987 return resultobj;
13988 fail:
13989 return NULL;
13990 }
13991
13992
13993 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
13994 PyObject *resultobj;
13995 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13996 wxString *result;
13997 PyObject * obj0 = 0 ;
13998 char *kwnames[] = {
13999 (char *) "self", NULL
14000 };
14001
14002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14004 if (SWIG_arg_fail(1)) SWIG_fail;
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 {
14008 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14009 result = (wxString *) &_result_ref;
14010 }
14011
14012 wxPyEndAllowThreads(__tstate);
14013 if (PyErr_Occurred()) SWIG_fail;
14014 }
14015 {
14016 #if wxUSE_UNICODE
14017 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14018 #else
14019 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14020 #endif
14021 }
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj;
14030 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14031 int result;
14032 PyObject * obj0 = 0 ;
14033 char *kwnames[] = {
14034 (char *) "self", NULL
14035 };
14036
14037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14039 if (SWIG_arg_fail(1)) SWIG_fail;
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14043
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 {
14048 resultobj = SWIG_From_int((int)(result));
14049 }
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14057 PyObject *obj;
14058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14059 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14060 Py_INCREF(obj);
14061 return Py_BuildValue((char *)"");
14062 }
14063 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14064 PyObject *resultobj;
14065 wxFileTypeInfo *arg1 = 0 ;
14066 wxFileType *result;
14067 PyObject * obj0 = 0 ;
14068 char *kwnames[] = {
14069 (char *) "ftInfo", NULL
14070 };
14071
14072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14073 {
14074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14075 if (SWIG_arg_fail(1)) SWIG_fail;
14076 if (arg1 == NULL) {
14077 SWIG_null_ref("wxFileTypeInfo");
14078 }
14079 if (SWIG_arg_fail(1)) SWIG_fail;
14080 }
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14084
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj;
14097 wxFileType *arg1 = (wxFileType *) 0 ;
14098 PyObject * obj0 = 0 ;
14099 char *kwnames[] = {
14100 (char *) "self", NULL
14101 };
14102
14103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14105 if (SWIG_arg_fail(1)) SWIG_fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 delete arg1;
14109
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 Py_INCREF(Py_None); resultobj = Py_None;
14114 return resultobj;
14115 fail:
14116 return NULL;
14117 }
14118
14119
14120 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14121 PyObject *resultobj;
14122 wxFileType *arg1 = (wxFileType *) 0 ;
14123 PyObject *result;
14124 PyObject * obj0 = 0 ;
14125 char *kwnames[] = {
14126 (char *) "self", NULL
14127 };
14128
14129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14131 if (SWIG_arg_fail(1)) SWIG_fail;
14132 {
14133 PyThreadState* __tstate = wxPyBeginAllowThreads();
14134 result = (PyObject *)wxFileType_GetMimeType(arg1);
14135
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 resultobj = result;
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj;
14148 wxFileType *arg1 = (wxFileType *) 0 ;
14149 PyObject *result;
14150 PyObject * obj0 = 0 ;
14151 char *kwnames[] = {
14152 (char *) "self", NULL
14153 };
14154
14155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14157 if (SWIG_arg_fail(1)) SWIG_fail;
14158 {
14159 PyThreadState* __tstate = wxPyBeginAllowThreads();
14160 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14161
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 resultobj = result;
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14173 PyObject *resultobj;
14174 wxFileType *arg1 = (wxFileType *) 0 ;
14175 PyObject *result;
14176 PyObject * obj0 = 0 ;
14177 char *kwnames[] = {
14178 (char *) "self", NULL
14179 };
14180
14181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14183 if (SWIG_arg_fail(1)) SWIG_fail;
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (PyObject *)wxFileType_GetExtensions(arg1);
14187
14188 wxPyEndAllowThreads(__tstate);
14189 if (PyErr_Occurred()) SWIG_fail;
14190 }
14191 resultobj = result;
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj;
14200 wxFileType *arg1 = (wxFileType *) 0 ;
14201 wxIcon *result;
14202 PyObject * obj0 = 0 ;
14203 char *kwnames[] = {
14204 (char *) "self", NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14209 if (SWIG_arg_fail(1)) SWIG_fail;
14210 {
14211 PyThreadState* __tstate = wxPyBeginAllowThreads();
14212 result = (wxIcon *)wxFileType_GetIcon(arg1);
14213
14214 wxPyEndAllowThreads(__tstate);
14215 if (PyErr_Occurred()) SWIG_fail;
14216 }
14217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14225 PyObject *resultobj;
14226 wxFileType *arg1 = (wxFileType *) 0 ;
14227 PyObject *result;
14228 PyObject * obj0 = 0 ;
14229 char *kwnames[] = {
14230 (char *) "self", NULL
14231 };
14232
14233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14239
14240 wxPyEndAllowThreads(__tstate);
14241 if (PyErr_Occurred()) SWIG_fail;
14242 }
14243 resultobj = result;
14244 return resultobj;
14245 fail:
14246 return NULL;
14247 }
14248
14249
14250 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj;
14252 wxFileType *arg1 = (wxFileType *) 0 ;
14253 PyObject *result;
14254 PyObject * obj0 = 0 ;
14255 char *kwnames[] = {
14256 (char *) "self", NULL
14257 };
14258
14259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(1)) SWIG_fail;
14262 {
14263 PyThreadState* __tstate = wxPyBeginAllowThreads();
14264 result = (PyObject *)wxFileType_GetDescription(arg1);
14265
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 resultobj = result;
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14277 PyObject *resultobj;
14278 wxFileType *arg1 = (wxFileType *) 0 ;
14279 wxString *arg2 = 0 ;
14280 wxString const &arg3_defvalue = wxPyEmptyString ;
14281 wxString *arg3 = (wxString *) &arg3_defvalue ;
14282 PyObject *result;
14283 bool temp2 = false ;
14284 bool temp3 = false ;
14285 PyObject * obj0 = 0 ;
14286 PyObject * obj1 = 0 ;
14287 PyObject * obj2 = 0 ;
14288 char *kwnames[] = {
14289 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14290 };
14291
14292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14294 if (SWIG_arg_fail(1)) SWIG_fail;
14295 {
14296 arg2 = wxString_in_helper(obj1);
14297 if (arg2 == NULL) SWIG_fail;
14298 temp2 = true;
14299 }
14300 if (obj2) {
14301 {
14302 arg3 = wxString_in_helper(obj2);
14303 if (arg3 == NULL) SWIG_fail;
14304 temp3 = true;
14305 }
14306 }
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 resultobj = result;
14315 {
14316 if (temp2)
14317 delete arg2;
14318 }
14319 {
14320 if (temp3)
14321 delete arg3;
14322 }
14323 return resultobj;
14324 fail:
14325 {
14326 if (temp2)
14327 delete arg2;
14328 }
14329 {
14330 if (temp3)
14331 delete arg3;
14332 }
14333 return NULL;
14334 }
14335
14336
14337 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14338 PyObject *resultobj;
14339 wxFileType *arg1 = (wxFileType *) 0 ;
14340 wxString *arg2 = 0 ;
14341 wxString const &arg3_defvalue = wxPyEmptyString ;
14342 wxString *arg3 = (wxString *) &arg3_defvalue ;
14343 PyObject *result;
14344 bool temp2 = false ;
14345 bool temp3 = false ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 PyObject * obj2 = 0 ;
14349 char *kwnames[] = {
14350 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14351 };
14352
14353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14355 if (SWIG_arg_fail(1)) SWIG_fail;
14356 {
14357 arg2 = wxString_in_helper(obj1);
14358 if (arg2 == NULL) SWIG_fail;
14359 temp2 = true;
14360 }
14361 if (obj2) {
14362 {
14363 arg3 = wxString_in_helper(obj2);
14364 if (arg3 == NULL) SWIG_fail;
14365 temp3 = true;
14366 }
14367 }
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14371
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 resultobj = result;
14376 {
14377 if (temp2)
14378 delete arg2;
14379 }
14380 {
14381 if (temp3)
14382 delete arg3;
14383 }
14384 return resultobj;
14385 fail:
14386 {
14387 if (temp2)
14388 delete arg2;
14389 }
14390 {
14391 if (temp3)
14392 delete arg3;
14393 }
14394 return NULL;
14395 }
14396
14397
14398 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14399 PyObject *resultobj;
14400 wxFileType *arg1 = (wxFileType *) 0 ;
14401 wxString *arg2 = 0 ;
14402 wxString const &arg3_defvalue = wxPyEmptyString ;
14403 wxString *arg3 = (wxString *) &arg3_defvalue ;
14404 PyObject *result;
14405 bool temp2 = false ;
14406 bool temp3 = false ;
14407 PyObject * obj0 = 0 ;
14408 PyObject * obj1 = 0 ;
14409 PyObject * obj2 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 {
14418 arg2 = wxString_in_helper(obj1);
14419 if (arg2 == NULL) SWIG_fail;
14420 temp2 = true;
14421 }
14422 if (obj2) {
14423 {
14424 arg3 = wxString_in_helper(obj2);
14425 if (arg3 == NULL) SWIG_fail;
14426 temp3 = true;
14427 }
14428 }
14429 {
14430 PyThreadState* __tstate = wxPyBeginAllowThreads();
14431 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14432
14433 wxPyEndAllowThreads(__tstate);
14434 if (PyErr_Occurred()) SWIG_fail;
14435 }
14436 resultobj = result;
14437 {
14438 if (temp2)
14439 delete arg2;
14440 }
14441 {
14442 if (temp3)
14443 delete arg3;
14444 }
14445 return resultobj;
14446 fail:
14447 {
14448 if (temp2)
14449 delete arg2;
14450 }
14451 {
14452 if (temp3)
14453 delete arg3;
14454 }
14455 return NULL;
14456 }
14457
14458
14459 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj;
14461 wxFileType *arg1 = (wxFileType *) 0 ;
14462 wxString *arg2 = 0 ;
14463 wxString *arg3 = 0 ;
14464 bool arg4 = (bool) true ;
14465 bool result;
14466 bool temp2 = false ;
14467 bool temp3 = false ;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 PyObject * obj2 = 0 ;
14471 PyObject * obj3 = 0 ;
14472 char *kwnames[] = {
14473 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14474 };
14475
14476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14478 if (SWIG_arg_fail(1)) SWIG_fail;
14479 {
14480 arg2 = wxString_in_helper(obj1);
14481 if (arg2 == NULL) SWIG_fail;
14482 temp2 = true;
14483 }
14484 {
14485 arg3 = wxString_in_helper(obj2);
14486 if (arg3 == NULL) SWIG_fail;
14487 temp3 = true;
14488 }
14489 if (obj3) {
14490 {
14491 arg4 = (bool)(SWIG_As_bool(obj3));
14492 if (SWIG_arg_fail(4)) SWIG_fail;
14493 }
14494 }
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 {
14503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14504 }
14505 {
14506 if (temp2)
14507 delete arg2;
14508 }
14509 {
14510 if (temp3)
14511 delete arg3;
14512 }
14513 return resultobj;
14514 fail:
14515 {
14516 if (temp2)
14517 delete arg2;
14518 }
14519 {
14520 if (temp3)
14521 delete arg3;
14522 }
14523 return NULL;
14524 }
14525
14526
14527 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14528 PyObject *resultobj;
14529 wxFileType *arg1 = (wxFileType *) 0 ;
14530 wxString const &arg2_defvalue = wxPyEmptyString ;
14531 wxString *arg2 = (wxString *) &arg2_defvalue ;
14532 int arg3 = (int) 0 ;
14533 bool result;
14534 bool temp2 = false ;
14535 PyObject * obj0 = 0 ;
14536 PyObject * obj1 = 0 ;
14537 PyObject * obj2 = 0 ;
14538 char *kwnames[] = {
14539 (char *) "self",(char *) "cmd",(char *) "index", NULL
14540 };
14541
14542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14544 if (SWIG_arg_fail(1)) SWIG_fail;
14545 if (obj1) {
14546 {
14547 arg2 = wxString_in_helper(obj1);
14548 if (arg2 == NULL) SWIG_fail;
14549 temp2 = true;
14550 }
14551 }
14552 if (obj2) {
14553 {
14554 arg3 = (int)(SWIG_As_int(obj2));
14555 if (SWIG_arg_fail(3)) SWIG_fail;
14556 }
14557 }
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14567 }
14568 {
14569 if (temp2)
14570 delete arg2;
14571 }
14572 return resultobj;
14573 fail:
14574 {
14575 if (temp2)
14576 delete arg2;
14577 }
14578 return NULL;
14579 }
14580
14581
14582 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14583 PyObject *resultobj;
14584 wxFileType *arg1 = (wxFileType *) 0 ;
14585 bool result;
14586 PyObject * obj0 = 0 ;
14587 char *kwnames[] = {
14588 (char *) "self", NULL
14589 };
14590
14591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14593 if (SWIG_arg_fail(1)) SWIG_fail;
14594 {
14595 PyThreadState* __tstate = wxPyBeginAllowThreads();
14596 result = (bool)(arg1)->Unassociate();
14597
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 {
14602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14603 }
14604 return resultobj;
14605 fail:
14606 return NULL;
14607 }
14608
14609
14610 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14611 PyObject *resultobj;
14612 wxString *arg1 = 0 ;
14613 wxString *arg2 = 0 ;
14614 wxString const &arg3_defvalue = wxPyEmptyString ;
14615 wxString *arg3 = (wxString *) &arg3_defvalue ;
14616 wxString result;
14617 bool temp1 = false ;
14618 bool temp2 = false ;
14619 bool temp3 = false ;
14620 PyObject * obj0 = 0 ;
14621 PyObject * obj1 = 0 ;
14622 PyObject * obj2 = 0 ;
14623 char *kwnames[] = {
14624 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14625 };
14626
14627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14628 {
14629 arg1 = wxString_in_helper(obj0);
14630 if (arg1 == NULL) SWIG_fail;
14631 temp1 = true;
14632 }
14633 {
14634 arg2 = wxString_in_helper(obj1);
14635 if (arg2 == NULL) SWIG_fail;
14636 temp2 = true;
14637 }
14638 if (obj2) {
14639 {
14640 arg3 = wxString_in_helper(obj2);
14641 if (arg3 == NULL) SWIG_fail;
14642 temp3 = true;
14643 }
14644 }
14645 {
14646 PyThreadState* __tstate = wxPyBeginAllowThreads();
14647 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14648
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 {
14653 #if wxUSE_UNICODE
14654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14655 #else
14656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14657 #endif
14658 }
14659 {
14660 if (temp1)
14661 delete arg1;
14662 }
14663 {
14664 if (temp2)
14665 delete arg2;
14666 }
14667 {
14668 if (temp3)
14669 delete arg3;
14670 }
14671 return resultobj;
14672 fail:
14673 {
14674 if (temp1)
14675 delete arg1;
14676 }
14677 {
14678 if (temp2)
14679 delete arg2;
14680 }
14681 {
14682 if (temp3)
14683 delete arg3;
14684 }
14685 return NULL;
14686 }
14687
14688
14689 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14690 PyObject *obj;
14691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14692 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14693 Py_INCREF(obj);
14694 return Py_BuildValue((char *)"");
14695 }
14696 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14697 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14698 return 1;
14699 }
14700
14701
14702 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14703 PyObject *pyobj;
14704
14705 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14706 return pyobj;
14707 }
14708
14709
14710 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14711 PyObject *resultobj;
14712 wxString *arg1 = 0 ;
14713 wxString *arg2 = 0 ;
14714 bool result;
14715 bool temp1 = false ;
14716 bool temp2 = false ;
14717 PyObject * obj0 = 0 ;
14718 PyObject * obj1 = 0 ;
14719 char *kwnames[] = {
14720 (char *) "mimeType",(char *) "wildcard", NULL
14721 };
14722
14723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14724 {
14725 arg1 = wxString_in_helper(obj0);
14726 if (arg1 == NULL) SWIG_fail;
14727 temp1 = true;
14728 }
14729 {
14730 arg2 = wxString_in_helper(obj1);
14731 if (arg2 == NULL) SWIG_fail;
14732 temp2 = true;
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14737
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 {
14742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14743 }
14744 {
14745 if (temp1)
14746 delete arg1;
14747 }
14748 {
14749 if (temp2)
14750 delete arg2;
14751 }
14752 return resultobj;
14753 fail:
14754 {
14755 if (temp1)
14756 delete arg1;
14757 }
14758 {
14759 if (temp2)
14760 delete arg2;
14761 }
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxMimeTypesManager *result;
14769 char *kwnames[] = {
14770 NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14777
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14789 PyObject *resultobj;
14790 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14791 int arg2 = (int) wxMAILCAP_ALL ;
14792 wxString const &arg3_defvalue = wxPyEmptyString ;
14793 wxString *arg3 = (wxString *) &arg3_defvalue ;
14794 bool temp3 = false ;
14795 PyObject * obj0 = 0 ;
14796 PyObject * obj1 = 0 ;
14797 PyObject * obj2 = 0 ;
14798 char *kwnames[] = {
14799 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14800 };
14801
14802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14804 if (SWIG_arg_fail(1)) SWIG_fail;
14805 if (obj1) {
14806 {
14807 arg2 = (int)(SWIG_As_int(obj1));
14808 if (SWIG_arg_fail(2)) SWIG_fail;
14809 }
14810 }
14811 if (obj2) {
14812 {
14813 arg3 = wxString_in_helper(obj2);
14814 if (arg3 == NULL) SWIG_fail;
14815 temp3 = true;
14816 }
14817 }
14818 {
14819 PyThreadState* __tstate = wxPyBeginAllowThreads();
14820 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14821
14822 wxPyEndAllowThreads(__tstate);
14823 if (PyErr_Occurred()) SWIG_fail;
14824 }
14825 Py_INCREF(Py_None); resultobj = Py_None;
14826 {
14827 if (temp3)
14828 delete arg3;
14829 }
14830 return resultobj;
14831 fail:
14832 {
14833 if (temp3)
14834 delete arg3;
14835 }
14836 return NULL;
14837 }
14838
14839
14840 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14841 PyObject *resultobj;
14842 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14843 PyObject * obj0 = 0 ;
14844 char *kwnames[] = {
14845 (char *) "self", NULL
14846 };
14847
14848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14850 if (SWIG_arg_fail(1)) SWIG_fail;
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 (arg1)->ClearData();
14854
14855 wxPyEndAllowThreads(__tstate);
14856 if (PyErr_Occurred()) SWIG_fail;
14857 }
14858 Py_INCREF(Py_None); resultobj = Py_None;
14859 return resultobj;
14860 fail:
14861 return NULL;
14862 }
14863
14864
14865 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj;
14867 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14868 wxString *arg2 = 0 ;
14869 wxFileType *result;
14870 bool temp2 = false ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 char *kwnames[] = {
14874 (char *) "self",(char *) "ext", NULL
14875 };
14876
14877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14879 if (SWIG_arg_fail(1)) SWIG_fail;
14880 {
14881 arg2 = wxString_in_helper(obj1);
14882 if (arg2 == NULL) SWIG_fail;
14883 temp2 = true;
14884 }
14885 {
14886 PyThreadState* __tstate = wxPyBeginAllowThreads();
14887 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14888
14889 wxPyEndAllowThreads(__tstate);
14890 if (PyErr_Occurred()) SWIG_fail;
14891 }
14892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14893 {
14894 if (temp2)
14895 delete arg2;
14896 }
14897 return resultobj;
14898 fail:
14899 {
14900 if (temp2)
14901 delete arg2;
14902 }
14903 return NULL;
14904 }
14905
14906
14907 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14908 PyObject *resultobj;
14909 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14910 wxString *arg2 = 0 ;
14911 wxFileType *result;
14912 bool temp2 = false ;
14913 PyObject * obj0 = 0 ;
14914 PyObject * obj1 = 0 ;
14915 char *kwnames[] = {
14916 (char *) "self",(char *) "mimeType", NULL
14917 };
14918
14919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14921 if (SWIG_arg_fail(1)) SWIG_fail;
14922 {
14923 arg2 = wxString_in_helper(obj1);
14924 if (arg2 == NULL) SWIG_fail;
14925 temp2 = true;
14926 }
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14930
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14935 {
14936 if (temp2)
14937 delete arg2;
14938 }
14939 return resultobj;
14940 fail:
14941 {
14942 if (temp2)
14943 delete arg2;
14944 }
14945 return NULL;
14946 }
14947
14948
14949 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj;
14951 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14952 wxString *arg2 = 0 ;
14953 bool arg3 = (bool) false ;
14954 bool result;
14955 bool temp2 = false ;
14956 PyObject * obj0 = 0 ;
14957 PyObject * obj1 = 0 ;
14958 PyObject * obj2 = 0 ;
14959 char *kwnames[] = {
14960 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14961 };
14962
14963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14965 if (SWIG_arg_fail(1)) SWIG_fail;
14966 {
14967 arg2 = wxString_in_helper(obj1);
14968 if (arg2 == NULL) SWIG_fail;
14969 temp2 = true;
14970 }
14971 if (obj2) {
14972 {
14973 arg3 = (bool)(SWIG_As_bool(obj2));
14974 if (SWIG_arg_fail(3)) SWIG_fail;
14975 }
14976 }
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 {
14985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14986 }
14987 {
14988 if (temp2)
14989 delete arg2;
14990 }
14991 return resultobj;
14992 fail:
14993 {
14994 if (temp2)
14995 delete arg2;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj;
15003 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15004 wxString *arg2 = 0 ;
15005 bool result;
15006 bool temp2 = false ;
15007 PyObject * obj0 = 0 ;
15008 PyObject * obj1 = 0 ;
15009 char *kwnames[] = {
15010 (char *) "self",(char *) "filename", NULL
15011 };
15012
15013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15015 if (SWIG_arg_fail(1)) SWIG_fail;
15016 {
15017 arg2 = wxString_in_helper(obj1);
15018 if (arg2 == NULL) SWIG_fail;
15019 temp2 = true;
15020 }
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 {
15029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15030 }
15031 {
15032 if (temp2)
15033 delete arg2;
15034 }
15035 return resultobj;
15036 fail:
15037 {
15038 if (temp2)
15039 delete arg2;
15040 }
15041 return NULL;
15042 }
15043
15044
15045 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15046 PyObject *resultobj;
15047 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15048 PyObject *result;
15049 PyObject * obj0 = 0 ;
15050 char *kwnames[] = {
15051 (char *) "self", NULL
15052 };
15053
15054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15056 if (SWIG_arg_fail(1)) SWIG_fail;
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15060
15061 wxPyEndAllowThreads(__tstate);
15062 if (PyErr_Occurred()) SWIG_fail;
15063 }
15064 resultobj = result;
15065 return resultobj;
15066 fail:
15067 return NULL;
15068 }
15069
15070
15071 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15072 PyObject *resultobj;
15073 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15074 wxFileTypeInfo *arg2 = 0 ;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 char *kwnames[] = {
15078 (char *) "self",(char *) "ft", NULL
15079 };
15080
15081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15083 if (SWIG_arg_fail(1)) SWIG_fail;
15084 {
15085 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15086 if (SWIG_arg_fail(2)) SWIG_fail;
15087 if (arg2 == NULL) {
15088 SWIG_null_ref("wxFileTypeInfo");
15089 }
15090 if (SWIG_arg_fail(2)) SWIG_fail;
15091 }
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15095
15096 wxPyEndAllowThreads(__tstate);
15097 if (PyErr_Occurred()) SWIG_fail;
15098 }
15099 Py_INCREF(Py_None); resultobj = Py_None;
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15107 PyObject *resultobj;
15108 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15109 wxFileTypeInfo *arg2 = 0 ;
15110 wxFileType *result;
15111 PyObject * obj0 = 0 ;
15112 PyObject * obj1 = 0 ;
15113 char *kwnames[] = {
15114 (char *) "self",(char *) "ftInfo", NULL
15115 };
15116
15117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15119 if (SWIG_arg_fail(1)) SWIG_fail;
15120 {
15121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(2)) SWIG_fail;
15123 if (arg2 == NULL) {
15124 SWIG_null_ref("wxFileTypeInfo");
15125 }
15126 if (SWIG_arg_fail(2)) SWIG_fail;
15127 }
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj;
15144 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15145 wxFileType *arg2 = (wxFileType *) 0 ;
15146 bool result;
15147 PyObject * obj0 = 0 ;
15148 PyObject * obj1 = 0 ;
15149 char *kwnames[] = {
15150 (char *) "self",(char *) "ft", NULL
15151 };
15152
15153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15155 if (SWIG_arg_fail(1)) SWIG_fail;
15156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15157 if (SWIG_arg_fail(2)) SWIG_fail;
15158 {
15159 PyThreadState* __tstate = wxPyBeginAllowThreads();
15160 result = (bool)(arg1)->Unassociate(arg2);
15161
15162 wxPyEndAllowThreads(__tstate);
15163 if (PyErr_Occurred()) SWIG_fail;
15164 }
15165 {
15166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15167 }
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj;
15176 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15177 PyObject * obj0 = 0 ;
15178 char *kwnames[] = {
15179 (char *) "self", NULL
15180 };
15181
15182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15184 if (SWIG_arg_fail(1)) SWIG_fail;
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 delete arg1;
15188
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 Py_INCREF(Py_None); resultobj = Py_None;
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15200 PyObject *obj;
15201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15202 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15203 Py_INCREF(obj);
15204 return Py_BuildValue((char *)"");
15205 }
15206 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15207 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15208 return 1;
15209 }
15210
15211
15212 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15213 PyObject *pyobj;
15214
15215 {
15216 #if wxUSE_UNICODE
15217 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15218 #else
15219 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15220 #endif
15221 }
15222 return pyobj;
15223 }
15224
15225
15226 static int _wrap_ART_MENU_set(PyObject *) {
15227 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15228 return 1;
15229 }
15230
15231
15232 static PyObject *_wrap_ART_MENU_get(void) {
15233 PyObject *pyobj;
15234
15235 {
15236 #if wxUSE_UNICODE
15237 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15238 #else
15239 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15240 #endif
15241 }
15242 return pyobj;
15243 }
15244
15245
15246 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15247 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15248 return 1;
15249 }
15250
15251
15252 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15253 PyObject *pyobj;
15254
15255 {
15256 #if wxUSE_UNICODE
15257 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15258 #else
15259 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15260 #endif
15261 }
15262 return pyobj;
15263 }
15264
15265
15266 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15267 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15268 return 1;
15269 }
15270
15271
15272 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15273 PyObject *pyobj;
15274
15275 {
15276 #if wxUSE_UNICODE
15277 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15278 #else
15279 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15280 #endif
15281 }
15282 return pyobj;
15283 }
15284
15285
15286 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15287 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15288 return 1;
15289 }
15290
15291
15292 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15293 PyObject *pyobj;
15294
15295 {
15296 #if wxUSE_UNICODE
15297 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15298 #else
15299 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15300 #endif
15301 }
15302 return pyobj;
15303 }
15304
15305
15306 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15307 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15308 return 1;
15309 }
15310
15311
15312 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15313 PyObject *pyobj;
15314
15315 {
15316 #if wxUSE_UNICODE
15317 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15318 #else
15319 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15320 #endif
15321 }
15322 return pyobj;
15323 }
15324
15325
15326 static int _wrap_ART_BUTTON_set(PyObject *) {
15327 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15328 return 1;
15329 }
15330
15331
15332 static PyObject *_wrap_ART_BUTTON_get(void) {
15333 PyObject *pyobj;
15334
15335 {
15336 #if wxUSE_UNICODE
15337 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15338 #else
15339 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15340 #endif
15341 }
15342 return pyobj;
15343 }
15344
15345
15346 static int _wrap_ART_OTHER_set(PyObject *) {
15347 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15348 return 1;
15349 }
15350
15351
15352 static PyObject *_wrap_ART_OTHER_get(void) {
15353 PyObject *pyobj;
15354
15355 {
15356 #if wxUSE_UNICODE
15357 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15358 #else
15359 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15360 #endif
15361 }
15362 return pyobj;
15363 }
15364
15365
15366 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15367 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15368 return 1;
15369 }
15370
15371
15372 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15373 PyObject *pyobj;
15374
15375 {
15376 #if wxUSE_UNICODE
15377 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15378 #else
15379 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15380 #endif
15381 }
15382 return pyobj;
15383 }
15384
15385
15386 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15387 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15388 return 1;
15389 }
15390
15391
15392 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15393 PyObject *pyobj;
15394
15395 {
15396 #if wxUSE_UNICODE
15397 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15398 #else
15399 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15400 #endif
15401 }
15402 return pyobj;
15403 }
15404
15405
15406 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15407 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15408 return 1;
15409 }
15410
15411
15412 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15413 PyObject *pyobj;
15414
15415 {
15416 #if wxUSE_UNICODE
15417 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15418 #else
15419 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15420 #endif
15421 }
15422 return pyobj;
15423 }
15424
15425
15426 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15427 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15428 return 1;
15429 }
15430
15431
15432 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15433 PyObject *pyobj;
15434
15435 {
15436 #if wxUSE_UNICODE
15437 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15438 #else
15439 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15440 #endif
15441 }
15442 return pyobj;
15443 }
15444
15445
15446 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15447 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15448 return 1;
15449 }
15450
15451
15452 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15453 PyObject *pyobj;
15454
15455 {
15456 #if wxUSE_UNICODE
15457 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15458 #else
15459 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15460 #endif
15461 }
15462 return pyobj;
15463 }
15464
15465
15466 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15467 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15468 return 1;
15469 }
15470
15471
15472 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15473 PyObject *pyobj;
15474
15475 {
15476 #if wxUSE_UNICODE
15477 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15478 #else
15479 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15480 #endif
15481 }
15482 return pyobj;
15483 }
15484
15485
15486 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15487 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15488 return 1;
15489 }
15490
15491
15492 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15493 PyObject *pyobj;
15494
15495 {
15496 #if wxUSE_UNICODE
15497 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15498 #else
15499 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15500 #endif
15501 }
15502 return pyobj;
15503 }
15504
15505
15506 static int _wrap_ART_GO_BACK_set(PyObject *) {
15507 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15508 return 1;
15509 }
15510
15511
15512 static PyObject *_wrap_ART_GO_BACK_get(void) {
15513 PyObject *pyobj;
15514
15515 {
15516 #if wxUSE_UNICODE
15517 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15518 #else
15519 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15520 #endif
15521 }
15522 return pyobj;
15523 }
15524
15525
15526 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15527 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15528 return 1;
15529 }
15530
15531
15532 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15533 PyObject *pyobj;
15534
15535 {
15536 #if wxUSE_UNICODE
15537 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15538 #else
15539 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15540 #endif
15541 }
15542 return pyobj;
15543 }
15544
15545
15546 static int _wrap_ART_GO_UP_set(PyObject *) {
15547 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15548 return 1;
15549 }
15550
15551
15552 static PyObject *_wrap_ART_GO_UP_get(void) {
15553 PyObject *pyobj;
15554
15555 {
15556 #if wxUSE_UNICODE
15557 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15558 #else
15559 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15560 #endif
15561 }
15562 return pyobj;
15563 }
15564
15565
15566 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15567 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15568 return 1;
15569 }
15570
15571
15572 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15573 PyObject *pyobj;
15574
15575 {
15576 #if wxUSE_UNICODE
15577 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15578 #else
15579 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15580 #endif
15581 }
15582 return pyobj;
15583 }
15584
15585
15586 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15587 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15588 return 1;
15589 }
15590
15591
15592 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15593 PyObject *pyobj;
15594
15595 {
15596 #if wxUSE_UNICODE
15597 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15598 #else
15599 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15600 #endif
15601 }
15602 return pyobj;
15603 }
15604
15605
15606 static int _wrap_ART_GO_HOME_set(PyObject *) {
15607 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15608 return 1;
15609 }
15610
15611
15612 static PyObject *_wrap_ART_GO_HOME_get(void) {
15613 PyObject *pyobj;
15614
15615 {
15616 #if wxUSE_UNICODE
15617 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15618 #else
15619 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15620 #endif
15621 }
15622 return pyobj;
15623 }
15624
15625
15626 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15627 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15628 return 1;
15629 }
15630
15631
15632 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15633 PyObject *pyobj;
15634
15635 {
15636 #if wxUSE_UNICODE
15637 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15638 #else
15639 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15640 #endif
15641 }
15642 return pyobj;
15643 }
15644
15645
15646 static int _wrap_ART_PRINT_set(PyObject *) {
15647 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15648 return 1;
15649 }
15650
15651
15652 static PyObject *_wrap_ART_PRINT_get(void) {
15653 PyObject *pyobj;
15654
15655 {
15656 #if wxUSE_UNICODE
15657 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15658 #else
15659 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15660 #endif
15661 }
15662 return pyobj;
15663 }
15664
15665
15666 static int _wrap_ART_HELP_set(PyObject *) {
15667 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15668 return 1;
15669 }
15670
15671
15672 static PyObject *_wrap_ART_HELP_get(void) {
15673 PyObject *pyobj;
15674
15675 {
15676 #if wxUSE_UNICODE
15677 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15678 #else
15679 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15680 #endif
15681 }
15682 return pyobj;
15683 }
15684
15685
15686 static int _wrap_ART_TIP_set(PyObject *) {
15687 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15688 return 1;
15689 }
15690
15691
15692 static PyObject *_wrap_ART_TIP_get(void) {
15693 PyObject *pyobj;
15694
15695 {
15696 #if wxUSE_UNICODE
15697 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15698 #else
15699 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15700 #endif
15701 }
15702 return pyobj;
15703 }
15704
15705
15706 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15707 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15708 return 1;
15709 }
15710
15711
15712 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15713 PyObject *pyobj;
15714
15715 {
15716 #if wxUSE_UNICODE
15717 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15718 #else
15719 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15720 #endif
15721 }
15722 return pyobj;
15723 }
15724
15725
15726 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15727 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15728 return 1;
15729 }
15730
15731
15732 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15733 PyObject *pyobj;
15734
15735 {
15736 #if wxUSE_UNICODE
15737 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15738 #else
15739 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15740 #endif
15741 }
15742 return pyobj;
15743 }
15744
15745
15746 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15747 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15748 return 1;
15749 }
15750
15751
15752 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15753 PyObject *pyobj;
15754
15755 {
15756 #if wxUSE_UNICODE
15757 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15758 #else
15759 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15760 #endif
15761 }
15762 return pyobj;
15763 }
15764
15765
15766 static int _wrap_ART_HARDDISK_set(PyObject *) {
15767 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15768 return 1;
15769 }
15770
15771
15772 static PyObject *_wrap_ART_HARDDISK_get(void) {
15773 PyObject *pyobj;
15774
15775 {
15776 #if wxUSE_UNICODE
15777 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15778 #else
15779 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15780 #endif
15781 }
15782 return pyobj;
15783 }
15784
15785
15786 static int _wrap_ART_FLOPPY_set(PyObject *) {
15787 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15788 return 1;
15789 }
15790
15791
15792 static PyObject *_wrap_ART_FLOPPY_get(void) {
15793 PyObject *pyobj;
15794
15795 {
15796 #if wxUSE_UNICODE
15797 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15798 #else
15799 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15800 #endif
15801 }
15802 return pyobj;
15803 }
15804
15805
15806 static int _wrap_ART_CDROM_set(PyObject *) {
15807 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15808 return 1;
15809 }
15810
15811
15812 static PyObject *_wrap_ART_CDROM_get(void) {
15813 PyObject *pyobj;
15814
15815 {
15816 #if wxUSE_UNICODE
15817 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15818 #else
15819 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15820 #endif
15821 }
15822 return pyobj;
15823 }
15824
15825
15826 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15827 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15828 return 1;
15829 }
15830
15831
15832 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15833 PyObject *pyobj;
15834
15835 {
15836 #if wxUSE_UNICODE
15837 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15838 #else
15839 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15840 #endif
15841 }
15842 return pyobj;
15843 }
15844
15845
15846 static int _wrap_ART_FOLDER_set(PyObject *) {
15847 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15848 return 1;
15849 }
15850
15851
15852 static PyObject *_wrap_ART_FOLDER_get(void) {
15853 PyObject *pyobj;
15854
15855 {
15856 #if wxUSE_UNICODE
15857 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15858 #else
15859 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15860 #endif
15861 }
15862 return pyobj;
15863 }
15864
15865
15866 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15867 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15868 return 1;
15869 }
15870
15871
15872 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15873 PyObject *pyobj;
15874
15875 {
15876 #if wxUSE_UNICODE
15877 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15878 #else
15879 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15880 #endif
15881 }
15882 return pyobj;
15883 }
15884
15885
15886 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15887 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15888 return 1;
15889 }
15890
15891
15892 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15893 PyObject *pyobj;
15894
15895 {
15896 #if wxUSE_UNICODE
15897 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15898 #else
15899 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15900 #endif
15901 }
15902 return pyobj;
15903 }
15904
15905
15906 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15907 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15908 return 1;
15909 }
15910
15911
15912 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15913 PyObject *pyobj;
15914
15915 {
15916 #if wxUSE_UNICODE
15917 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15918 #else
15919 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15920 #endif
15921 }
15922 return pyobj;
15923 }
15924
15925
15926 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15927 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15928 return 1;
15929 }
15930
15931
15932 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15933 PyObject *pyobj;
15934
15935 {
15936 #if wxUSE_UNICODE
15937 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15938 #else
15939 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15940 #endif
15941 }
15942 return pyobj;
15943 }
15944
15945
15946 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15947 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15948 return 1;
15949 }
15950
15951
15952 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15953 PyObject *pyobj;
15954
15955 {
15956 #if wxUSE_UNICODE
15957 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15958 #else
15959 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15960 #endif
15961 }
15962 return pyobj;
15963 }
15964
15965
15966 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15967 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15968 return 1;
15969 }
15970
15971
15972 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15973 PyObject *pyobj;
15974
15975 {
15976 #if wxUSE_UNICODE
15977 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15978 #else
15979 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15980 #endif
15981 }
15982 return pyobj;
15983 }
15984
15985
15986 static int _wrap_ART_ERROR_set(PyObject *) {
15987 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
15988 return 1;
15989 }
15990
15991
15992 static PyObject *_wrap_ART_ERROR_get(void) {
15993 PyObject *pyobj;
15994
15995 {
15996 #if wxUSE_UNICODE
15997 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
15998 #else
15999 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16000 #endif
16001 }
16002 return pyobj;
16003 }
16004
16005
16006 static int _wrap_ART_QUESTION_set(PyObject *) {
16007 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16008 return 1;
16009 }
16010
16011
16012 static PyObject *_wrap_ART_QUESTION_get(void) {
16013 PyObject *pyobj;
16014
16015 {
16016 #if wxUSE_UNICODE
16017 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16018 #else
16019 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16020 #endif
16021 }
16022 return pyobj;
16023 }
16024
16025
16026 static int _wrap_ART_WARNING_set(PyObject *) {
16027 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16028 return 1;
16029 }
16030
16031
16032 static PyObject *_wrap_ART_WARNING_get(void) {
16033 PyObject *pyobj;
16034
16035 {
16036 #if wxUSE_UNICODE
16037 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16038 #else
16039 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16040 #endif
16041 }
16042 return pyobj;
16043 }
16044
16045
16046 static int _wrap_ART_INFORMATION_set(PyObject *) {
16047 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16048 return 1;
16049 }
16050
16051
16052 static PyObject *_wrap_ART_INFORMATION_get(void) {
16053 PyObject *pyobj;
16054
16055 {
16056 #if wxUSE_UNICODE
16057 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16058 #else
16059 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16060 #endif
16061 }
16062 return pyobj;
16063 }
16064
16065
16066 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16067 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16068 return 1;
16069 }
16070
16071
16072 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16073 PyObject *pyobj;
16074
16075 {
16076 #if wxUSE_UNICODE
16077 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16078 #else
16079 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16080 #endif
16081 }
16082 return pyobj;
16083 }
16084
16085
16086 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16087 PyObject *resultobj;
16088 wxPyArtProvider *result;
16089 char *kwnames[] = {
16090 NULL
16091 };
16092
16093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16094 {
16095 if (!wxPyCheckForApp()) SWIG_fail;
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (wxPyArtProvider *)new wxPyArtProvider();
16098
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16110 PyObject *resultobj;
16111 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16112 PyObject *arg2 = (PyObject *) 0 ;
16113 PyObject *arg3 = (PyObject *) 0 ;
16114 PyObject * obj0 = 0 ;
16115 PyObject * obj1 = 0 ;
16116 PyObject * obj2 = 0 ;
16117 char *kwnames[] = {
16118 (char *) "self",(char *) "self",(char *) "_class", NULL
16119 };
16120
16121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16123 if (SWIG_arg_fail(1)) SWIG_fail;
16124 arg2 = obj1;
16125 arg3 = obj2;
16126 {
16127 PyThreadState* __tstate = wxPyBeginAllowThreads();
16128 (arg1)->_setCallbackInfo(arg2,arg3);
16129
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 Py_INCREF(Py_None); resultobj = Py_None;
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj;
16142 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16143 PyObject * obj0 = 0 ;
16144 char *kwnames[] = {
16145 (char *) "provider", NULL
16146 };
16147
16148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16150 if (SWIG_arg_fail(1)) SWIG_fail;
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 wxPyArtProvider::PushProvider(arg1);
16154
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 Py_INCREF(Py_None); resultobj = Py_None;
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj;
16167 bool result;
16168 char *kwnames[] = {
16169 NULL
16170 };
16171
16172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 result = (bool)wxPyArtProvider::PopProvider();
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 {
16181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16182 }
16183 return resultobj;
16184 fail:
16185 return NULL;
16186 }
16187
16188
16189 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16190 PyObject *resultobj;
16191 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16192 bool result;
16193 PyObject * obj0 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "provider", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16204
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 {
16209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16210 }
16211 return resultobj;
16212 fail:
16213 return NULL;
16214 }
16215
16216
16217 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj;
16219 wxString *arg1 = 0 ;
16220 wxString const &arg2_defvalue = wxPyART_OTHER ;
16221 wxString *arg2 = (wxString *) &arg2_defvalue ;
16222 wxSize const &arg3_defvalue = wxDefaultSize ;
16223 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16224 wxBitmap result;
16225 bool temp1 = false ;
16226 bool temp2 = false ;
16227 wxSize temp3 ;
16228 PyObject * obj0 = 0 ;
16229 PyObject * obj1 = 0 ;
16230 PyObject * obj2 = 0 ;
16231 char *kwnames[] = {
16232 (char *) "id",(char *) "client",(char *) "size", NULL
16233 };
16234
16235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16236 {
16237 arg1 = wxString_in_helper(obj0);
16238 if (arg1 == NULL) SWIG_fail;
16239 temp1 = true;
16240 }
16241 if (obj1) {
16242 {
16243 arg2 = wxString_in_helper(obj1);
16244 if (arg2 == NULL) SWIG_fail;
16245 temp2 = true;
16246 }
16247 }
16248 if (obj2) {
16249 {
16250 arg3 = &temp3;
16251 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16252 }
16253 }
16254 {
16255 if (!wxPyCheckForApp()) SWIG_fail;
16256 PyThreadState* __tstate = wxPyBeginAllowThreads();
16257 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16258
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 {
16263 wxBitmap * resultptr;
16264 resultptr = new wxBitmap((wxBitmap &)(result));
16265 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16266 }
16267 {
16268 if (temp1)
16269 delete arg1;
16270 }
16271 {
16272 if (temp2)
16273 delete arg2;
16274 }
16275 return resultobj;
16276 fail:
16277 {
16278 if (temp1)
16279 delete arg1;
16280 }
16281 {
16282 if (temp2)
16283 delete arg2;
16284 }
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxString *arg1 = 0 ;
16292 wxString const &arg2_defvalue = wxPyART_OTHER ;
16293 wxString *arg2 = (wxString *) &arg2_defvalue ;
16294 wxSize const &arg3_defvalue = wxDefaultSize ;
16295 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16296 wxIcon result;
16297 bool temp1 = false ;
16298 bool temp2 = false ;
16299 wxSize temp3 ;
16300 PyObject * obj0 = 0 ;
16301 PyObject * obj1 = 0 ;
16302 PyObject * obj2 = 0 ;
16303 char *kwnames[] = {
16304 (char *) "id",(char *) "client",(char *) "size", NULL
16305 };
16306
16307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16308 {
16309 arg1 = wxString_in_helper(obj0);
16310 if (arg1 == NULL) SWIG_fail;
16311 temp1 = true;
16312 }
16313 if (obj1) {
16314 {
16315 arg2 = wxString_in_helper(obj1);
16316 if (arg2 == NULL) SWIG_fail;
16317 temp2 = true;
16318 }
16319 }
16320 if (obj2) {
16321 {
16322 arg3 = &temp3;
16323 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16324 }
16325 }
16326 {
16327 if (!wxPyCheckForApp()) SWIG_fail;
16328 PyThreadState* __tstate = wxPyBeginAllowThreads();
16329 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16330
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 {
16335 wxIcon * resultptr;
16336 resultptr = new wxIcon((wxIcon &)(result));
16337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16338 }
16339 {
16340 if (temp1)
16341 delete arg1;
16342 }
16343 {
16344 if (temp2)
16345 delete arg2;
16346 }
16347 return resultobj;
16348 fail:
16349 {
16350 if (temp1)
16351 delete arg1;
16352 }
16353 {
16354 if (temp2)
16355 delete arg2;
16356 }
16357 return NULL;
16358 }
16359
16360
16361 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16362 PyObject *resultobj;
16363 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16364 PyObject * obj0 = 0 ;
16365 char *kwnames[] = {
16366 (char *) "self", NULL
16367 };
16368
16369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16371 if (SWIG_arg_fail(1)) SWIG_fail;
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 wxPyArtProvider_Destroy(arg1);
16375
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 Py_INCREF(Py_None); resultobj = Py_None;
16380 return resultobj;
16381 fail:
16382 return NULL;
16383 }
16384
16385
16386 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16387 PyObject *obj;
16388 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16389 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16390 Py_INCREF(obj);
16391 return Py_BuildValue((char *)"");
16392 }
16393 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj;
16395 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16396 PyObject * obj0 = 0 ;
16397 char *kwnames[] = {
16398 (char *) "self", NULL
16399 };
16400
16401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16403 if (SWIG_arg_fail(1)) SWIG_fail;
16404 {
16405 PyThreadState* __tstate = wxPyBeginAllowThreads();
16406 delete arg1;
16407
16408 wxPyEndAllowThreads(__tstate);
16409 if (PyErr_Occurred()) SWIG_fail;
16410 }
16411 Py_INCREF(Py_None); resultobj = Py_None;
16412 return resultobj;
16413 fail:
16414 return NULL;
16415 }
16416
16417
16418 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16419 PyObject *resultobj;
16420 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16421 wxConfigBase *result;
16422 PyObject * obj0 = 0 ;
16423 char *kwnames[] = {
16424 (char *) "config", NULL
16425 };
16426
16427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16429 if (SWIG_arg_fail(1)) SWIG_fail;
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16433
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj;
16446 bool arg1 = (bool) true ;
16447 wxConfigBase *result;
16448 PyObject * obj0 = 0 ;
16449 char *kwnames[] = {
16450 (char *) "createOnDemand", NULL
16451 };
16452
16453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16454 if (obj0) {
16455 {
16456 arg1 = (bool)(SWIG_As_bool(obj0));
16457 if (SWIG_arg_fail(1)) SWIG_fail;
16458 }
16459 }
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16463
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxConfigBase *result;
16477 char *kwnames[] = {
16478 NULL
16479 };
16480
16481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 result = (wxConfigBase *)wxConfigBase::Create();
16485
16486 wxPyEndAllowThreads(__tstate);
16487 if (PyErr_Occurred()) SWIG_fail;
16488 }
16489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16490 return resultobj;
16491 fail:
16492 return NULL;
16493 }
16494
16495
16496 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16497 PyObject *resultobj;
16498 char *kwnames[] = {
16499 NULL
16500 };
16501
16502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16503 {
16504 PyThreadState* __tstate = wxPyBeginAllowThreads();
16505 wxConfigBase::DontCreateOnDemand();
16506
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 Py_INCREF(Py_None); resultobj = Py_None;
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj;
16519 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16520 wxString *arg2 = 0 ;
16521 bool temp2 = false ;
16522 PyObject * obj0 = 0 ;
16523 PyObject * obj1 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "self",(char *) "path", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 {
16532 arg2 = wxString_in_helper(obj1);
16533 if (arg2 == NULL) SWIG_fail;
16534 temp2 = true;
16535 }
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 (arg1)->SetPath((wxString const &)*arg2);
16539
16540 wxPyEndAllowThreads(__tstate);
16541 if (PyErr_Occurred()) SWIG_fail;
16542 }
16543 Py_INCREF(Py_None); resultobj = Py_None;
16544 {
16545 if (temp2)
16546 delete arg2;
16547 }
16548 return resultobj;
16549 fail:
16550 {
16551 if (temp2)
16552 delete arg2;
16553 }
16554 return NULL;
16555 }
16556
16557
16558 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj;
16560 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16561 wxString *result;
16562 PyObject * obj0 = 0 ;
16563 char *kwnames[] = {
16564 (char *) "self", NULL
16565 };
16566
16567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16569 if (SWIG_arg_fail(1)) SWIG_fail;
16570 {
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 {
16573 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16574 result = (wxString *) &_result_ref;
16575 }
16576
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 #if wxUSE_UNICODE
16582 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16583 #else
16584 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16585 #endif
16586 }
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj;
16595 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16596 PyObject *result;
16597 PyObject * obj0 = 0 ;
16598 char *kwnames[] = {
16599 (char *) "self", NULL
16600 };
16601
16602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16604 if (SWIG_arg_fail(1)) SWIG_fail;
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16608
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 resultobj = result;
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj;
16621 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16622 long arg2 ;
16623 PyObject *result;
16624 PyObject * obj0 = 0 ;
16625 PyObject * obj1 = 0 ;
16626 char *kwnames[] = {
16627 (char *) "self",(char *) "index", NULL
16628 };
16629
16630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16632 if (SWIG_arg_fail(1)) SWIG_fail;
16633 {
16634 arg2 = (long)(SWIG_As_long(obj1));
16635 if (SWIG_arg_fail(2)) SWIG_fail;
16636 }
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16640
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 resultobj = result;
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj;
16653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16654 PyObject *result;
16655 PyObject * obj0 = 0 ;
16656 char *kwnames[] = {
16657 (char *) "self", NULL
16658 };
16659
16660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16662 if (SWIG_arg_fail(1)) SWIG_fail;
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16666
16667 wxPyEndAllowThreads(__tstate);
16668 if (PyErr_Occurred()) SWIG_fail;
16669 }
16670 resultobj = result;
16671 return resultobj;
16672 fail:
16673 return NULL;
16674 }
16675
16676
16677 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16678 PyObject *resultobj;
16679 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16680 long arg2 ;
16681 PyObject *result;
16682 PyObject * obj0 = 0 ;
16683 PyObject * obj1 = 0 ;
16684 char *kwnames[] = {
16685 (char *) "self",(char *) "index", NULL
16686 };
16687
16688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16690 if (SWIG_arg_fail(1)) SWIG_fail;
16691 {
16692 arg2 = (long)(SWIG_As_long(obj1));
16693 if (SWIG_arg_fail(2)) SWIG_fail;
16694 }
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16698
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = result;
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16710 PyObject *resultobj;
16711 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16712 bool arg2 = (bool) false ;
16713 size_t result;
16714 PyObject * obj0 = 0 ;
16715 PyObject * obj1 = 0 ;
16716 char *kwnames[] = {
16717 (char *) "self",(char *) "recursive", NULL
16718 };
16719
16720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16722 if (SWIG_arg_fail(1)) SWIG_fail;
16723 if (obj1) {
16724 {
16725 arg2 = (bool)(SWIG_As_bool(obj1));
16726 if (SWIG_arg_fail(2)) SWIG_fail;
16727 }
16728 }
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16732
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 {
16737 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj;
16747 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16748 bool arg2 = (bool) false ;
16749 size_t result;
16750 PyObject * obj0 = 0 ;
16751 PyObject * obj1 = 0 ;
16752 char *kwnames[] = {
16753 (char *) "self",(char *) "recursive", NULL
16754 };
16755
16756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16758 if (SWIG_arg_fail(1)) SWIG_fail;
16759 if (obj1) {
16760 {
16761 arg2 = (bool)(SWIG_As_bool(obj1));
16762 if (SWIG_arg_fail(2)) SWIG_fail;
16763 }
16764 }
16765 {
16766 PyThreadState* __tstate = wxPyBeginAllowThreads();
16767 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16768
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 {
16773 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16774 }
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj;
16783 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16784 wxString *arg2 = 0 ;
16785 bool result;
16786 bool temp2 = false ;
16787 PyObject * obj0 = 0 ;
16788 PyObject * obj1 = 0 ;
16789 char *kwnames[] = {
16790 (char *) "self",(char *) "name", NULL
16791 };
16792
16793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16795 if (SWIG_arg_fail(1)) SWIG_fail;
16796 {
16797 arg2 = wxString_in_helper(obj1);
16798 if (arg2 == NULL) SWIG_fail;
16799 temp2 = true;
16800 }
16801 {
16802 PyThreadState* __tstate = wxPyBeginAllowThreads();
16803 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16804
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 {
16809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16810 }
16811 {
16812 if (temp2)
16813 delete arg2;
16814 }
16815 return resultobj;
16816 fail:
16817 {
16818 if (temp2)
16819 delete arg2;
16820 }
16821 return NULL;
16822 }
16823
16824
16825 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj;
16827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16828 wxString *arg2 = 0 ;
16829 bool result;
16830 bool temp2 = false ;
16831 PyObject * obj0 = 0 ;
16832 PyObject * obj1 = 0 ;
16833 char *kwnames[] = {
16834 (char *) "self",(char *) "name", NULL
16835 };
16836
16837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16839 if (SWIG_arg_fail(1)) SWIG_fail;
16840 {
16841 arg2 = wxString_in_helper(obj1);
16842 if (arg2 == NULL) SWIG_fail;
16843 temp2 = true;
16844 }
16845 {
16846 PyThreadState* __tstate = wxPyBeginAllowThreads();
16847 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16848
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16854 }
16855 {
16856 if (temp2)
16857 delete arg2;
16858 }
16859 return resultobj;
16860 fail:
16861 {
16862 if (temp2)
16863 delete arg2;
16864 }
16865 return NULL;
16866 }
16867
16868
16869 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj;
16871 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16872 wxString *arg2 = 0 ;
16873 bool result;
16874 bool temp2 = false ;
16875 PyObject * obj0 = 0 ;
16876 PyObject * obj1 = 0 ;
16877 char *kwnames[] = {
16878 (char *) "self",(char *) "name", NULL
16879 };
16880
16881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16883 if (SWIG_arg_fail(1)) SWIG_fail;
16884 {
16885 arg2 = wxString_in_helper(obj1);
16886 if (arg2 == NULL) SWIG_fail;
16887 temp2 = true;
16888 }
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16892
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 {
16897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16898 }
16899 {
16900 if (temp2)
16901 delete arg2;
16902 }
16903 return resultobj;
16904 fail:
16905 {
16906 if (temp2)
16907 delete arg2;
16908 }
16909 return NULL;
16910 }
16911
16912
16913 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16916 wxString *arg2 = 0 ;
16917 wxConfigBase::EntryType result;
16918 bool temp2 = false ;
16919 PyObject * obj0 = 0 ;
16920 PyObject * obj1 = 0 ;
16921 char *kwnames[] = {
16922 (char *) "self",(char *) "name", NULL
16923 };
16924
16925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16927 if (SWIG_arg_fail(1)) SWIG_fail;
16928 {
16929 arg2 = wxString_in_helper(obj1);
16930 if (arg2 == NULL) SWIG_fail;
16931 temp2 = true;
16932 }
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16936
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 resultobj = SWIG_From_int((result));
16941 {
16942 if (temp2)
16943 delete arg2;
16944 }
16945 return resultobj;
16946 fail:
16947 {
16948 if (temp2)
16949 delete arg2;
16950 }
16951 return NULL;
16952 }
16953
16954
16955 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj;
16957 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16958 wxString *arg2 = 0 ;
16959 wxString const &arg3_defvalue = wxPyEmptyString ;
16960 wxString *arg3 = (wxString *) &arg3_defvalue ;
16961 wxString result;
16962 bool temp2 = false ;
16963 bool temp3 = false ;
16964 PyObject * obj0 = 0 ;
16965 PyObject * obj1 = 0 ;
16966 PyObject * obj2 = 0 ;
16967 char *kwnames[] = {
16968 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16969 };
16970
16971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16973 if (SWIG_arg_fail(1)) SWIG_fail;
16974 {
16975 arg2 = wxString_in_helper(obj1);
16976 if (arg2 == NULL) SWIG_fail;
16977 temp2 = true;
16978 }
16979 if (obj2) {
16980 {
16981 arg3 = wxString_in_helper(obj2);
16982 if (arg3 == NULL) SWIG_fail;
16983 temp3 = true;
16984 }
16985 }
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
16989
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 #if wxUSE_UNICODE
16995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16996 #else
16997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16998 #endif
16999 }
17000 {
17001 if (temp2)
17002 delete arg2;
17003 }
17004 {
17005 if (temp3)
17006 delete arg3;
17007 }
17008 return resultobj;
17009 fail:
17010 {
17011 if (temp2)
17012 delete arg2;
17013 }
17014 {
17015 if (temp3)
17016 delete arg3;
17017 }
17018 return NULL;
17019 }
17020
17021
17022 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17023 PyObject *resultobj;
17024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17025 wxString *arg2 = 0 ;
17026 long arg3 = (long) 0 ;
17027 long result;
17028 bool temp2 = false ;
17029 PyObject * obj0 = 0 ;
17030 PyObject * obj1 = 0 ;
17031 PyObject * obj2 = 0 ;
17032 char *kwnames[] = {
17033 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17034 };
17035
17036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17038 if (SWIG_arg_fail(1)) SWIG_fail;
17039 {
17040 arg2 = wxString_in_helper(obj1);
17041 if (arg2 == NULL) SWIG_fail;
17042 temp2 = true;
17043 }
17044 if (obj2) {
17045 {
17046 arg3 = (long)(SWIG_As_long(obj2));
17047 if (SWIG_arg_fail(3)) SWIG_fail;
17048 }
17049 }
17050 {
17051 PyThreadState* __tstate = wxPyBeginAllowThreads();
17052 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17053
17054 wxPyEndAllowThreads(__tstate);
17055 if (PyErr_Occurred()) SWIG_fail;
17056 }
17057 {
17058 resultobj = SWIG_From_long((long)(result));
17059 }
17060 {
17061 if (temp2)
17062 delete arg2;
17063 }
17064 return resultobj;
17065 fail:
17066 {
17067 if (temp2)
17068 delete arg2;
17069 }
17070 return NULL;
17071 }
17072
17073
17074 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17075 PyObject *resultobj;
17076 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17077 wxString *arg2 = 0 ;
17078 double arg3 = (double) 0.0 ;
17079 double result;
17080 bool temp2 = false ;
17081 PyObject * obj0 = 0 ;
17082 PyObject * obj1 = 0 ;
17083 PyObject * obj2 = 0 ;
17084 char *kwnames[] = {
17085 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17086 };
17087
17088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17090 if (SWIG_arg_fail(1)) SWIG_fail;
17091 {
17092 arg2 = wxString_in_helper(obj1);
17093 if (arg2 == NULL) SWIG_fail;
17094 temp2 = true;
17095 }
17096 if (obj2) {
17097 {
17098 arg3 = (double)(SWIG_As_double(obj2));
17099 if (SWIG_arg_fail(3)) SWIG_fail;
17100 }
17101 }
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17105
17106 wxPyEndAllowThreads(__tstate);
17107 if (PyErr_Occurred()) SWIG_fail;
17108 }
17109 {
17110 resultobj = SWIG_From_double((double)(result));
17111 }
17112 {
17113 if (temp2)
17114 delete arg2;
17115 }
17116 return resultobj;
17117 fail:
17118 {
17119 if (temp2)
17120 delete arg2;
17121 }
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17129 wxString *arg2 = 0 ;
17130 bool arg3 = (bool) false ;
17131 bool result;
17132 bool temp2 = false ;
17133 PyObject * obj0 = 0 ;
17134 PyObject * obj1 = 0 ;
17135 PyObject * obj2 = 0 ;
17136 char *kwnames[] = {
17137 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17138 };
17139
17140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17142 if (SWIG_arg_fail(1)) SWIG_fail;
17143 {
17144 arg2 = wxString_in_helper(obj1);
17145 if (arg2 == NULL) SWIG_fail;
17146 temp2 = true;
17147 }
17148 if (obj2) {
17149 {
17150 arg3 = (bool)(SWIG_As_bool(obj2));
17151 if (SWIG_arg_fail(3)) SWIG_fail;
17152 }
17153 }
17154 {
17155 PyThreadState* __tstate = wxPyBeginAllowThreads();
17156 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17157
17158 wxPyEndAllowThreads(__tstate);
17159 if (PyErr_Occurred()) SWIG_fail;
17160 }
17161 {
17162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17163 }
17164 {
17165 if (temp2)
17166 delete arg2;
17167 }
17168 return resultobj;
17169 fail:
17170 {
17171 if (temp2)
17172 delete arg2;
17173 }
17174 return NULL;
17175 }
17176
17177
17178 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj;
17180 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17181 wxString *arg2 = 0 ;
17182 wxString *arg3 = 0 ;
17183 bool result;
17184 bool temp2 = false ;
17185 bool temp3 = false ;
17186 PyObject * obj0 = 0 ;
17187 PyObject * obj1 = 0 ;
17188 PyObject * obj2 = 0 ;
17189 char *kwnames[] = {
17190 (char *) "self",(char *) "key",(char *) "value", NULL
17191 };
17192
17193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17195 if (SWIG_arg_fail(1)) SWIG_fail;
17196 {
17197 arg2 = wxString_in_helper(obj1);
17198 if (arg2 == NULL) SWIG_fail;
17199 temp2 = true;
17200 }
17201 {
17202 arg3 = wxString_in_helper(obj2);
17203 if (arg3 == NULL) SWIG_fail;
17204 temp3 = true;
17205 }
17206 {
17207 PyThreadState* __tstate = wxPyBeginAllowThreads();
17208 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17209
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 {
17214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17215 }
17216 {
17217 if (temp2)
17218 delete arg2;
17219 }
17220 {
17221 if (temp3)
17222 delete arg3;
17223 }
17224 return resultobj;
17225 fail:
17226 {
17227 if (temp2)
17228 delete arg2;
17229 }
17230 {
17231 if (temp3)
17232 delete arg3;
17233 }
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj;
17240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17241 wxString *arg2 = 0 ;
17242 long arg3 ;
17243 bool result;
17244 bool temp2 = false ;
17245 PyObject * obj0 = 0 ;
17246 PyObject * obj1 = 0 ;
17247 PyObject * obj2 = 0 ;
17248 char *kwnames[] = {
17249 (char *) "self",(char *) "key",(char *) "value", NULL
17250 };
17251
17252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17254 if (SWIG_arg_fail(1)) SWIG_fail;
17255 {
17256 arg2 = wxString_in_helper(obj1);
17257 if (arg2 == NULL) SWIG_fail;
17258 temp2 = true;
17259 }
17260 {
17261 arg3 = (long)(SWIG_As_long(obj2));
17262 if (SWIG_arg_fail(3)) SWIG_fail;
17263 }
17264 {
17265 PyThreadState* __tstate = wxPyBeginAllowThreads();
17266 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17267
17268 wxPyEndAllowThreads(__tstate);
17269 if (PyErr_Occurred()) SWIG_fail;
17270 }
17271 {
17272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17273 }
17274 {
17275 if (temp2)
17276 delete arg2;
17277 }
17278 return resultobj;
17279 fail:
17280 {
17281 if (temp2)
17282 delete arg2;
17283 }
17284 return NULL;
17285 }
17286
17287
17288 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17289 PyObject *resultobj;
17290 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17291 wxString *arg2 = 0 ;
17292 double arg3 ;
17293 bool result;
17294 bool temp2 = false ;
17295 PyObject * obj0 = 0 ;
17296 PyObject * obj1 = 0 ;
17297 PyObject * obj2 = 0 ;
17298 char *kwnames[] = {
17299 (char *) "self",(char *) "key",(char *) "value", NULL
17300 };
17301
17302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17304 if (SWIG_arg_fail(1)) SWIG_fail;
17305 {
17306 arg2 = wxString_in_helper(obj1);
17307 if (arg2 == NULL) SWIG_fail;
17308 temp2 = true;
17309 }
17310 {
17311 arg3 = (double)(SWIG_As_double(obj2));
17312 if (SWIG_arg_fail(3)) SWIG_fail;
17313 }
17314 {
17315 PyThreadState* __tstate = wxPyBeginAllowThreads();
17316 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17317
17318 wxPyEndAllowThreads(__tstate);
17319 if (PyErr_Occurred()) SWIG_fail;
17320 }
17321 {
17322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17323 }
17324 {
17325 if (temp2)
17326 delete arg2;
17327 }
17328 return resultobj;
17329 fail:
17330 {
17331 if (temp2)
17332 delete arg2;
17333 }
17334 return NULL;
17335 }
17336
17337
17338 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17339 PyObject *resultobj;
17340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17341 wxString *arg2 = 0 ;
17342 bool arg3 ;
17343 bool result;
17344 bool temp2 = false ;
17345 PyObject * obj0 = 0 ;
17346 PyObject * obj1 = 0 ;
17347 PyObject * obj2 = 0 ;
17348 char *kwnames[] = {
17349 (char *) "self",(char *) "key",(char *) "value", NULL
17350 };
17351
17352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17354 if (SWIG_arg_fail(1)) SWIG_fail;
17355 {
17356 arg2 = wxString_in_helper(obj1);
17357 if (arg2 == NULL) SWIG_fail;
17358 temp2 = true;
17359 }
17360 {
17361 arg3 = (bool)(SWIG_As_bool(obj2));
17362 if (SWIG_arg_fail(3)) SWIG_fail;
17363 }
17364 {
17365 PyThreadState* __tstate = wxPyBeginAllowThreads();
17366 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17367
17368 wxPyEndAllowThreads(__tstate);
17369 if (PyErr_Occurred()) SWIG_fail;
17370 }
17371 {
17372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17373 }
17374 {
17375 if (temp2)
17376 delete arg2;
17377 }
17378 return resultobj;
17379 fail:
17380 {
17381 if (temp2)
17382 delete arg2;
17383 }
17384 return NULL;
17385 }
17386
17387
17388 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj;
17390 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17391 bool arg2 = (bool) false ;
17392 bool result;
17393 PyObject * obj0 = 0 ;
17394 PyObject * obj1 = 0 ;
17395 char *kwnames[] = {
17396 (char *) "self",(char *) "currentOnly", NULL
17397 };
17398
17399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17401 if (SWIG_arg_fail(1)) SWIG_fail;
17402 if (obj1) {
17403 {
17404 arg2 = (bool)(SWIG_As_bool(obj1));
17405 if (SWIG_arg_fail(2)) SWIG_fail;
17406 }
17407 }
17408 {
17409 PyThreadState* __tstate = wxPyBeginAllowThreads();
17410 result = (bool)(arg1)->Flush(arg2);
17411
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 {
17416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17417 }
17418 return resultobj;
17419 fail:
17420 return NULL;
17421 }
17422
17423
17424 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17425 PyObject *resultobj;
17426 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17427 wxString *arg2 = 0 ;
17428 wxString *arg3 = 0 ;
17429 bool result;
17430 bool temp2 = false ;
17431 bool temp3 = false ;
17432 PyObject * obj0 = 0 ;
17433 PyObject * obj1 = 0 ;
17434 PyObject * obj2 = 0 ;
17435 char *kwnames[] = {
17436 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17437 };
17438
17439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17441 if (SWIG_arg_fail(1)) SWIG_fail;
17442 {
17443 arg2 = wxString_in_helper(obj1);
17444 if (arg2 == NULL) SWIG_fail;
17445 temp2 = true;
17446 }
17447 {
17448 arg3 = wxString_in_helper(obj2);
17449 if (arg3 == NULL) SWIG_fail;
17450 temp3 = true;
17451 }
17452 {
17453 PyThreadState* __tstate = wxPyBeginAllowThreads();
17454 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17455
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 {
17460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17461 }
17462 {
17463 if (temp2)
17464 delete arg2;
17465 }
17466 {
17467 if (temp3)
17468 delete arg3;
17469 }
17470 return resultobj;
17471 fail:
17472 {
17473 if (temp2)
17474 delete arg2;
17475 }
17476 {
17477 if (temp3)
17478 delete arg3;
17479 }
17480 return NULL;
17481 }
17482
17483
17484 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17485 PyObject *resultobj;
17486 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17487 wxString *arg2 = 0 ;
17488 wxString *arg3 = 0 ;
17489 bool result;
17490 bool temp2 = false ;
17491 bool temp3 = false ;
17492 PyObject * obj0 = 0 ;
17493 PyObject * obj1 = 0 ;
17494 PyObject * obj2 = 0 ;
17495 char *kwnames[] = {
17496 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17497 };
17498
17499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17501 if (SWIG_arg_fail(1)) SWIG_fail;
17502 {
17503 arg2 = wxString_in_helper(obj1);
17504 if (arg2 == NULL) SWIG_fail;
17505 temp2 = true;
17506 }
17507 {
17508 arg3 = wxString_in_helper(obj2);
17509 if (arg3 == NULL) SWIG_fail;
17510 temp3 = true;
17511 }
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17515
17516 wxPyEndAllowThreads(__tstate);
17517 if (PyErr_Occurred()) SWIG_fail;
17518 }
17519 {
17520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17521 }
17522 {
17523 if (temp2)
17524 delete arg2;
17525 }
17526 {
17527 if (temp3)
17528 delete arg3;
17529 }
17530 return resultobj;
17531 fail:
17532 {
17533 if (temp2)
17534 delete arg2;
17535 }
17536 {
17537 if (temp3)
17538 delete arg3;
17539 }
17540 return NULL;
17541 }
17542
17543
17544 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17545 PyObject *resultobj;
17546 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17547 wxString *arg2 = 0 ;
17548 bool arg3 = (bool) true ;
17549 bool result;
17550 bool temp2 = false ;
17551 PyObject * obj0 = 0 ;
17552 PyObject * obj1 = 0 ;
17553 PyObject * obj2 = 0 ;
17554 char *kwnames[] = {
17555 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17556 };
17557
17558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17560 if (SWIG_arg_fail(1)) SWIG_fail;
17561 {
17562 arg2 = wxString_in_helper(obj1);
17563 if (arg2 == NULL) SWIG_fail;
17564 temp2 = true;
17565 }
17566 if (obj2) {
17567 {
17568 arg3 = (bool)(SWIG_As_bool(obj2));
17569 if (SWIG_arg_fail(3)) SWIG_fail;
17570 }
17571 }
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17575
17576 wxPyEndAllowThreads(__tstate);
17577 if (PyErr_Occurred()) SWIG_fail;
17578 }
17579 {
17580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17581 }
17582 {
17583 if (temp2)
17584 delete arg2;
17585 }
17586 return resultobj;
17587 fail:
17588 {
17589 if (temp2)
17590 delete arg2;
17591 }
17592 return NULL;
17593 }
17594
17595
17596 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17597 PyObject *resultobj;
17598 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17599 wxString *arg2 = 0 ;
17600 bool result;
17601 bool temp2 = false ;
17602 PyObject * obj0 = 0 ;
17603 PyObject * obj1 = 0 ;
17604 char *kwnames[] = {
17605 (char *) "self",(char *) "key", NULL
17606 };
17607
17608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17610 if (SWIG_arg_fail(1)) SWIG_fail;
17611 {
17612 arg2 = wxString_in_helper(obj1);
17613 if (arg2 == NULL) SWIG_fail;
17614 temp2 = true;
17615 }
17616 {
17617 PyThreadState* __tstate = wxPyBeginAllowThreads();
17618 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17619
17620 wxPyEndAllowThreads(__tstate);
17621 if (PyErr_Occurred()) SWIG_fail;
17622 }
17623 {
17624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17625 }
17626 {
17627 if (temp2)
17628 delete arg2;
17629 }
17630 return resultobj;
17631 fail:
17632 {
17633 if (temp2)
17634 delete arg2;
17635 }
17636 return NULL;
17637 }
17638
17639
17640 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17641 PyObject *resultobj;
17642 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17643 bool result;
17644 PyObject * obj0 = 0 ;
17645 char *kwnames[] = {
17646 (char *) "self", NULL
17647 };
17648
17649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17651 if (SWIG_arg_fail(1)) SWIG_fail;
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (bool)(arg1)->DeleteAll();
17655
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 {
17660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17661 }
17662 return resultobj;
17663 fail:
17664 return NULL;
17665 }
17666
17667
17668 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj;
17670 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17671 bool arg2 = (bool) true ;
17672 PyObject * obj0 = 0 ;
17673 PyObject * obj1 = 0 ;
17674 char *kwnames[] = {
17675 (char *) "self",(char *) "doIt", NULL
17676 };
17677
17678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17680 if (SWIG_arg_fail(1)) SWIG_fail;
17681 if (obj1) {
17682 {
17683 arg2 = (bool)(SWIG_As_bool(obj1));
17684 if (SWIG_arg_fail(2)) SWIG_fail;
17685 }
17686 }
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 (arg1)->SetExpandEnvVars(arg2);
17690
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 Py_INCREF(Py_None); resultobj = Py_None;
17695 return resultobj;
17696 fail:
17697 return NULL;
17698 }
17699
17700
17701 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17702 PyObject *resultobj;
17703 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17704 bool result;
17705 PyObject * obj0 = 0 ;
17706 char *kwnames[] = {
17707 (char *) "self", NULL
17708 };
17709
17710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17712 if (SWIG_arg_fail(1)) SWIG_fail;
17713 {
17714 PyThreadState* __tstate = wxPyBeginAllowThreads();
17715 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17716
17717 wxPyEndAllowThreads(__tstate);
17718 if (PyErr_Occurred()) SWIG_fail;
17719 }
17720 {
17721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17722 }
17723 return resultobj;
17724 fail:
17725 return NULL;
17726 }
17727
17728
17729 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17730 PyObject *resultobj;
17731 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17732 bool arg2 = (bool) true ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 char *kwnames[] = {
17736 (char *) "self",(char *) "doIt", NULL
17737 };
17738
17739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17741 if (SWIG_arg_fail(1)) SWIG_fail;
17742 if (obj1) {
17743 {
17744 arg2 = (bool)(SWIG_As_bool(obj1));
17745 if (SWIG_arg_fail(2)) SWIG_fail;
17746 }
17747 }
17748 {
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 (arg1)->SetRecordDefaults(arg2);
17751
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 Py_INCREF(Py_None); resultobj = Py_None;
17756 return resultobj;
17757 fail:
17758 return NULL;
17759 }
17760
17761
17762 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17763 PyObject *resultobj;
17764 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17765 bool result;
17766 PyObject * obj0 = 0 ;
17767 char *kwnames[] = {
17768 (char *) "self", NULL
17769 };
17770
17771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17773 if (SWIG_arg_fail(1)) SWIG_fail;
17774 {
17775 PyThreadState* __tstate = wxPyBeginAllowThreads();
17776 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17777
17778 wxPyEndAllowThreads(__tstate);
17779 if (PyErr_Occurred()) SWIG_fail;
17780 }
17781 {
17782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17783 }
17784 return resultobj;
17785 fail:
17786 return NULL;
17787 }
17788
17789
17790 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17791 PyObject *resultobj;
17792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17793 wxString *arg2 = 0 ;
17794 wxString result;
17795 bool temp2 = false ;
17796 PyObject * obj0 = 0 ;
17797 PyObject * obj1 = 0 ;
17798 char *kwnames[] = {
17799 (char *) "self",(char *) "str", NULL
17800 };
17801
17802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17804 if (SWIG_arg_fail(1)) SWIG_fail;
17805 {
17806 arg2 = wxString_in_helper(obj1);
17807 if (arg2 == NULL) SWIG_fail;
17808 temp2 = true;
17809 }
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17813
17814 wxPyEndAllowThreads(__tstate);
17815 if (PyErr_Occurred()) SWIG_fail;
17816 }
17817 {
17818 #if wxUSE_UNICODE
17819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17820 #else
17821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17822 #endif
17823 }
17824 {
17825 if (temp2)
17826 delete arg2;
17827 }
17828 return resultobj;
17829 fail:
17830 {
17831 if (temp2)
17832 delete arg2;
17833 }
17834 return NULL;
17835 }
17836
17837
17838 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17839 PyObject *resultobj;
17840 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17841 wxString result;
17842 PyObject * obj0 = 0 ;
17843 char *kwnames[] = {
17844 (char *) "self", NULL
17845 };
17846
17847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
17848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17849 if (SWIG_arg_fail(1)) SWIG_fail;
17850 {
17851 PyThreadState* __tstate = wxPyBeginAllowThreads();
17852 result = ((wxConfigBase const *)arg1)->GetAppName();
17853
17854 wxPyEndAllowThreads(__tstate);
17855 if (PyErr_Occurred()) SWIG_fail;
17856 }
17857 {
17858 #if wxUSE_UNICODE
17859 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17860 #else
17861 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17862 #endif
17863 }
17864 return resultobj;
17865 fail:
17866 return NULL;
17867 }
17868
17869
17870 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17871 PyObject *resultobj;
17872 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17873 wxString result;
17874 PyObject * obj0 = 0 ;
17875 char *kwnames[] = {
17876 (char *) "self", NULL
17877 };
17878
17879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17881 if (SWIG_arg_fail(1)) SWIG_fail;
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = ((wxConfigBase const *)arg1)->GetVendorName();
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 #if wxUSE_UNICODE
17891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17892 #else
17893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17894 #endif
17895 }
17896 return resultobj;
17897 fail:
17898 return NULL;
17899 }
17900
17901
17902 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17903 PyObject *resultobj;
17904 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17905 wxString *arg2 = 0 ;
17906 bool temp2 = false ;
17907 PyObject * obj0 = 0 ;
17908 PyObject * obj1 = 0 ;
17909 char *kwnames[] = {
17910 (char *) "self",(char *) "appName", NULL
17911 };
17912
17913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17915 if (SWIG_arg_fail(1)) SWIG_fail;
17916 {
17917 arg2 = wxString_in_helper(obj1);
17918 if (arg2 == NULL) SWIG_fail;
17919 temp2 = true;
17920 }
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 (arg1)->SetAppName((wxString const &)*arg2);
17924
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 Py_INCREF(Py_None); resultobj = Py_None;
17929 {
17930 if (temp2)
17931 delete arg2;
17932 }
17933 return resultobj;
17934 fail:
17935 {
17936 if (temp2)
17937 delete arg2;
17938 }
17939 return NULL;
17940 }
17941
17942
17943 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj;
17945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17946 wxString *arg2 = 0 ;
17947 bool temp2 = false ;
17948 PyObject * obj0 = 0 ;
17949 PyObject * obj1 = 0 ;
17950 char *kwnames[] = {
17951 (char *) "self",(char *) "vendorName", NULL
17952 };
17953
17954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17956 if (SWIG_arg_fail(1)) SWIG_fail;
17957 {
17958 arg2 = wxString_in_helper(obj1);
17959 if (arg2 == NULL) SWIG_fail;
17960 temp2 = true;
17961 }
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 (arg1)->SetVendorName((wxString const &)*arg2);
17965
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 Py_INCREF(Py_None); resultobj = Py_None;
17970 {
17971 if (temp2)
17972 delete arg2;
17973 }
17974 return resultobj;
17975 fail:
17976 {
17977 if (temp2)
17978 delete arg2;
17979 }
17980 return NULL;
17981 }
17982
17983
17984 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
17985 PyObject *resultobj;
17986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17987 long arg2 ;
17988 PyObject * obj0 = 0 ;
17989 PyObject * obj1 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self",(char *) "style", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 arg2 = (long)(SWIG_As_long(obj1));
17999 if (SWIG_arg_fail(2)) SWIG_fail;
18000 }
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 (arg1)->SetStyle(arg2);
18004
18005 wxPyEndAllowThreads(__tstate);
18006 if (PyErr_Occurred()) SWIG_fail;
18007 }
18008 Py_INCREF(Py_None); resultobj = Py_None;
18009 return resultobj;
18010 fail:
18011 return NULL;
18012 }
18013
18014
18015 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18016 PyObject *resultobj;
18017 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18018 long result;
18019 PyObject * obj0 = 0 ;
18020 char *kwnames[] = {
18021 (char *) "self", NULL
18022 };
18023
18024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18026 if (SWIG_arg_fail(1)) SWIG_fail;
18027 {
18028 PyThreadState* __tstate = wxPyBeginAllowThreads();
18029 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18030
18031 wxPyEndAllowThreads(__tstate);
18032 if (PyErr_Occurred()) SWIG_fail;
18033 }
18034 {
18035 resultobj = SWIG_From_long((long)(result));
18036 }
18037 return resultobj;
18038 fail:
18039 return NULL;
18040 }
18041
18042
18043 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18044 PyObject *obj;
18045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18046 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18047 Py_INCREF(obj);
18048 return Py_BuildValue((char *)"");
18049 }
18050 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18051 PyObject *resultobj;
18052 wxString const &arg1_defvalue = wxPyEmptyString ;
18053 wxString *arg1 = (wxString *) &arg1_defvalue ;
18054 wxString const &arg2_defvalue = wxPyEmptyString ;
18055 wxString *arg2 = (wxString *) &arg2_defvalue ;
18056 wxString const &arg3_defvalue = wxPyEmptyString ;
18057 wxString *arg3 = (wxString *) &arg3_defvalue ;
18058 wxString const &arg4_defvalue = wxPyEmptyString ;
18059 wxString *arg4 = (wxString *) &arg4_defvalue ;
18060 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18061 wxConfig *result;
18062 bool temp1 = false ;
18063 bool temp2 = false ;
18064 bool temp3 = false ;
18065 bool temp4 = false ;
18066 PyObject * obj0 = 0 ;
18067 PyObject * obj1 = 0 ;
18068 PyObject * obj2 = 0 ;
18069 PyObject * obj3 = 0 ;
18070 PyObject * obj4 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18076 if (obj0) {
18077 {
18078 arg1 = wxString_in_helper(obj0);
18079 if (arg1 == NULL) SWIG_fail;
18080 temp1 = true;
18081 }
18082 }
18083 if (obj1) {
18084 {
18085 arg2 = wxString_in_helper(obj1);
18086 if (arg2 == NULL) SWIG_fail;
18087 temp2 = true;
18088 }
18089 }
18090 if (obj2) {
18091 {
18092 arg3 = wxString_in_helper(obj2);
18093 if (arg3 == NULL) SWIG_fail;
18094 temp3 = true;
18095 }
18096 }
18097 if (obj3) {
18098 {
18099 arg4 = wxString_in_helper(obj3);
18100 if (arg4 == NULL) SWIG_fail;
18101 temp4 = true;
18102 }
18103 }
18104 if (obj4) {
18105 {
18106 arg5 = (long)(SWIG_As_long(obj4));
18107 if (SWIG_arg_fail(5)) SWIG_fail;
18108 }
18109 }
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18113
18114 wxPyEndAllowThreads(__tstate);
18115 if (PyErr_Occurred()) SWIG_fail;
18116 }
18117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18118 {
18119 if (temp1)
18120 delete arg1;
18121 }
18122 {
18123 if (temp2)
18124 delete arg2;
18125 }
18126 {
18127 if (temp3)
18128 delete arg3;
18129 }
18130 {
18131 if (temp4)
18132 delete arg4;
18133 }
18134 return resultobj;
18135 fail:
18136 {
18137 if (temp1)
18138 delete arg1;
18139 }
18140 {
18141 if (temp2)
18142 delete arg2;
18143 }
18144 {
18145 if (temp3)
18146 delete arg3;
18147 }
18148 {
18149 if (temp4)
18150 delete arg4;
18151 }
18152 return NULL;
18153 }
18154
18155
18156 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18157 PyObject *resultobj;
18158 wxConfig *arg1 = (wxConfig *) 0 ;
18159 PyObject * obj0 = 0 ;
18160 char *kwnames[] = {
18161 (char *) "self", NULL
18162 };
18163
18164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18166 if (SWIG_arg_fail(1)) SWIG_fail;
18167 {
18168 PyThreadState* __tstate = wxPyBeginAllowThreads();
18169 delete arg1;
18170
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 Py_INCREF(Py_None); resultobj = Py_None;
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18182 PyObject *obj;
18183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18184 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18185 Py_INCREF(obj);
18186 return Py_BuildValue((char *)"");
18187 }
18188 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18189 PyObject *resultobj;
18190 wxString const &arg1_defvalue = wxPyEmptyString ;
18191 wxString *arg1 = (wxString *) &arg1_defvalue ;
18192 wxString const &arg2_defvalue = wxPyEmptyString ;
18193 wxString *arg2 = (wxString *) &arg2_defvalue ;
18194 wxString const &arg3_defvalue = wxPyEmptyString ;
18195 wxString *arg3 = (wxString *) &arg3_defvalue ;
18196 wxString const &arg4_defvalue = wxPyEmptyString ;
18197 wxString *arg4 = (wxString *) &arg4_defvalue ;
18198 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18199 wxFileConfig *result;
18200 bool temp1 = false ;
18201 bool temp2 = false ;
18202 bool temp3 = false ;
18203 bool temp4 = false ;
18204 PyObject * obj0 = 0 ;
18205 PyObject * obj1 = 0 ;
18206 PyObject * obj2 = 0 ;
18207 PyObject * obj3 = 0 ;
18208 PyObject * obj4 = 0 ;
18209 char *kwnames[] = {
18210 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18211 };
18212
18213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18214 if (obj0) {
18215 {
18216 arg1 = wxString_in_helper(obj0);
18217 if (arg1 == NULL) SWIG_fail;
18218 temp1 = true;
18219 }
18220 }
18221 if (obj1) {
18222 {
18223 arg2 = wxString_in_helper(obj1);
18224 if (arg2 == NULL) SWIG_fail;
18225 temp2 = true;
18226 }
18227 }
18228 if (obj2) {
18229 {
18230 arg3 = wxString_in_helper(obj2);
18231 if (arg3 == NULL) SWIG_fail;
18232 temp3 = true;
18233 }
18234 }
18235 if (obj3) {
18236 {
18237 arg4 = wxString_in_helper(obj3);
18238 if (arg4 == NULL) SWIG_fail;
18239 temp4 = true;
18240 }
18241 }
18242 if (obj4) {
18243 {
18244 arg5 = (long)(SWIG_As_long(obj4));
18245 if (SWIG_arg_fail(5)) SWIG_fail;
18246 }
18247 }
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18251
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18256 {
18257 if (temp1)
18258 delete arg1;
18259 }
18260 {
18261 if (temp2)
18262 delete arg2;
18263 }
18264 {
18265 if (temp3)
18266 delete arg3;
18267 }
18268 {
18269 if (temp4)
18270 delete arg4;
18271 }
18272 return resultobj;
18273 fail:
18274 {
18275 if (temp1)
18276 delete arg1;
18277 }
18278 {
18279 if (temp2)
18280 delete arg2;
18281 }
18282 {
18283 if (temp3)
18284 delete arg3;
18285 }
18286 {
18287 if (temp4)
18288 delete arg4;
18289 }
18290 return NULL;
18291 }
18292
18293
18294 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj;
18296 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18297 PyObject * obj0 = 0 ;
18298 char *kwnames[] = {
18299 (char *) "self", NULL
18300 };
18301
18302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18304 if (SWIG_arg_fail(1)) SWIG_fail;
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 delete arg1;
18308
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 Py_INCREF(Py_None); resultobj = Py_None;
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18320 PyObject *obj;
18321 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18322 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18323 Py_INCREF(obj);
18324 return Py_BuildValue((char *)"");
18325 }
18326 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj;
18328 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18329 wxString *arg2 = 0 ;
18330 wxConfigPathChanger *result;
18331 bool temp2 = false ;
18332 PyObject * obj0 = 0 ;
18333 PyObject * obj1 = 0 ;
18334 char *kwnames[] = {
18335 (char *) "config",(char *) "entry", NULL
18336 };
18337
18338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18340 if (SWIG_arg_fail(1)) SWIG_fail;
18341 {
18342 arg2 = wxString_in_helper(obj1);
18343 if (arg2 == NULL) SWIG_fail;
18344 temp2 = true;
18345 }
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18349
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18354 {
18355 if (temp2)
18356 delete arg2;
18357 }
18358 return resultobj;
18359 fail:
18360 {
18361 if (temp2)
18362 delete arg2;
18363 }
18364 return NULL;
18365 }
18366
18367
18368 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18369 PyObject *resultobj;
18370 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18371 PyObject * obj0 = 0 ;
18372 char *kwnames[] = {
18373 (char *) "self", NULL
18374 };
18375
18376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18378 if (SWIG_arg_fail(1)) SWIG_fail;
18379 {
18380 PyThreadState* __tstate = wxPyBeginAllowThreads();
18381 delete arg1;
18382
18383 wxPyEndAllowThreads(__tstate);
18384 if (PyErr_Occurred()) SWIG_fail;
18385 }
18386 Py_INCREF(Py_None); resultobj = Py_None;
18387 return resultobj;
18388 fail:
18389 return NULL;
18390 }
18391
18392
18393 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18394 PyObject *resultobj;
18395 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18396 wxString *result;
18397 PyObject * obj0 = 0 ;
18398 char *kwnames[] = {
18399 (char *) "self", NULL
18400 };
18401
18402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18404 if (SWIG_arg_fail(1)) SWIG_fail;
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 {
18408 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18409 result = (wxString *) &_result_ref;
18410 }
18411
18412 wxPyEndAllowThreads(__tstate);
18413 if (PyErr_Occurred()) SWIG_fail;
18414 }
18415 {
18416 #if wxUSE_UNICODE
18417 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18418 #else
18419 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18420 #endif
18421 }
18422 return resultobj;
18423 fail:
18424 return NULL;
18425 }
18426
18427
18428 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18429 PyObject *obj;
18430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18431 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18432 Py_INCREF(obj);
18433 return Py_BuildValue((char *)"");
18434 }
18435 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18436 PyObject *resultobj;
18437 wxString *arg1 = 0 ;
18438 wxString result;
18439 bool temp1 = false ;
18440 PyObject * obj0 = 0 ;
18441 char *kwnames[] = {
18442 (char *) "sz", NULL
18443 };
18444
18445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18446 {
18447 arg1 = wxString_in_helper(obj0);
18448 if (arg1 == NULL) SWIG_fail;
18449 temp1 = true;
18450 }
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 result = wxExpandEnvVars((wxString const &)*arg1);
18454
18455 wxPyEndAllowThreads(__tstate);
18456 if (PyErr_Occurred()) SWIG_fail;
18457 }
18458 {
18459 #if wxUSE_UNICODE
18460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18461 #else
18462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18463 #endif
18464 }
18465 {
18466 if (temp1)
18467 delete arg1;
18468 }
18469 return resultobj;
18470 fail:
18471 {
18472 if (temp1)
18473 delete arg1;
18474 }
18475 return NULL;
18476 }
18477
18478
18479 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18480 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18481 return 1;
18482 }
18483
18484
18485 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18486 PyObject *pyobj;
18487
18488 {
18489 #if wxUSE_UNICODE
18490 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18491 #else
18492 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18493 #endif
18494 }
18495 return pyobj;
18496 }
18497
18498
18499 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18500 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18501 return 1;
18502 }
18503
18504
18505 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18506 PyObject *pyobj;
18507
18508 {
18509 #if wxUSE_UNICODE
18510 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18511 #else
18512 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18513 #endif
18514 }
18515 return pyobj;
18516 }
18517
18518
18519 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18520 PyObject *resultobj;
18521 wxDateTime::Country arg1 ;
18522 PyObject * obj0 = 0 ;
18523 char *kwnames[] = {
18524 (char *) "country", NULL
18525 };
18526
18527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18528 {
18529 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18530 if (SWIG_arg_fail(1)) SWIG_fail;
18531 }
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18535
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 Py_INCREF(Py_None); resultobj = Py_None;
18540 return resultobj;
18541 fail:
18542 return NULL;
18543 }
18544
18545
18546 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18547 PyObject *resultobj;
18548 wxDateTime::Country result;
18549 char *kwnames[] = {
18550 NULL
18551 };
18552
18553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 result = (wxDateTime::Country)wxDateTime::GetCountry();
18557
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 resultobj = SWIG_From_int((result));
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj;
18570 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18571 bool result;
18572 PyObject * obj0 = 0 ;
18573 char *kwnames[] = {
18574 (char *) "country", NULL
18575 };
18576
18577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18578 if (obj0) {
18579 {
18580 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18581 if (SWIG_arg_fail(1)) SWIG_fail;
18582 }
18583 }
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18587
18588 wxPyEndAllowThreads(__tstate);
18589 if (PyErr_Occurred()) SWIG_fail;
18590 }
18591 {
18592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18593 }
18594 return resultobj;
18595 fail:
18596 return NULL;
18597 }
18598
18599
18600 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj;
18602 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18603 int result;
18604 PyObject * obj0 = 0 ;
18605 char *kwnames[] = {
18606 (char *) "cal", NULL
18607 };
18608
18609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18610 if (obj0) {
18611 {
18612 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18613 if (SWIG_arg_fail(1)) SWIG_fail;
18614 }
18615 }
18616 {
18617 PyThreadState* __tstate = wxPyBeginAllowThreads();
18618 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18619
18620 wxPyEndAllowThreads(__tstate);
18621 if (PyErr_Occurred()) SWIG_fail;
18622 }
18623 {
18624 resultobj = SWIG_From_int((int)(result));
18625 }
18626 return resultobj;
18627 fail:
18628 return NULL;
18629 }
18630
18631
18632 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18633 PyObject *resultobj;
18634 int arg1 ;
18635 int result;
18636 PyObject * obj0 = 0 ;
18637 char *kwnames[] = {
18638 (char *) "year", NULL
18639 };
18640
18641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18642 {
18643 arg1 = (int)(SWIG_As_int(obj0));
18644 if (SWIG_arg_fail(1)) SWIG_fail;
18645 }
18646 {
18647 PyThreadState* __tstate = wxPyBeginAllowThreads();
18648 result = (int)wxDateTime::ConvertYearToBC(arg1);
18649
18650 wxPyEndAllowThreads(__tstate);
18651 if (PyErr_Occurred()) SWIG_fail;
18652 }
18653 {
18654 resultobj = SWIG_From_int((int)(result));
18655 }
18656 return resultobj;
18657 fail:
18658 return NULL;
18659 }
18660
18661
18662 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18663 PyObject *resultobj;
18664 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18665 wxDateTime::Month result;
18666 PyObject * obj0 = 0 ;
18667 char *kwnames[] = {
18668 (char *) "cal", NULL
18669 };
18670
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18672 if (obj0) {
18673 {
18674 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18675 if (SWIG_arg_fail(1)) SWIG_fail;
18676 }
18677 }
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_From_int((result));
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj;
18694 int arg1 = (int) wxDateTime::Inv_Year ;
18695 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18696 bool result;
18697 PyObject * obj0 = 0 ;
18698 PyObject * obj1 = 0 ;
18699 char *kwnames[] = {
18700 (char *) "year",(char *) "cal", NULL
18701 };
18702
18703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18704 if (obj0) {
18705 {
18706 arg1 = (int)(SWIG_As_int(obj0));
18707 if (SWIG_arg_fail(1)) SWIG_fail;
18708 }
18709 }
18710 if (obj1) {
18711 {
18712 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18713 if (SWIG_arg_fail(2)) SWIG_fail;
18714 }
18715 }
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18719
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 {
18724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18725 }
18726 return resultobj;
18727 fail:
18728 return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 int arg1 = (int) wxDateTime::Inv_Year ;
18735 int result;
18736 PyObject * obj0 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "year", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18742 if (obj0) {
18743 {
18744 arg1 = (int)(SWIG_As_int(obj0));
18745 if (SWIG_arg_fail(1)) SWIG_fail;
18746 }
18747 }
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (int)wxDateTime::GetCentury(arg1);
18751
18752 wxPyEndAllowThreads(__tstate);
18753 if (PyErr_Occurred()) SWIG_fail;
18754 }
18755 {
18756 resultobj = SWIG_From_int((int)(result));
18757 }
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj;
18766 int arg1 ;
18767 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18768 int result;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char *kwnames[] = {
18772 (char *) "year",(char *) "cal", NULL
18773 };
18774
18775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18776 {
18777 arg1 = (int)(SWIG_As_int(obj0));
18778 if (SWIG_arg_fail(1)) SWIG_fail;
18779 }
18780 if (obj1) {
18781 {
18782 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18783 if (SWIG_arg_fail(2)) SWIG_fail;
18784 }
18785 }
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18789
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 {
18794 resultobj = SWIG_From_int((int)(result));
18795 }
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj;
18804 wxDateTime::Month arg1 ;
18805 int arg2 = (int) wxDateTime::Inv_Year ;
18806 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18807 int result;
18808 PyObject * obj0 = 0 ;
18809 PyObject * obj1 = 0 ;
18810 PyObject * obj2 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "month",(char *) "year",(char *) "cal", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18816 {
18817 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18818 if (SWIG_arg_fail(1)) SWIG_fail;
18819 }
18820 if (obj1) {
18821 {
18822 arg2 = (int)(SWIG_As_int(obj1));
18823 if (SWIG_arg_fail(2)) SWIG_fail;
18824 }
18825 }
18826 if (obj2) {
18827 {
18828 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18829 if (SWIG_arg_fail(3)) SWIG_fail;
18830 }
18831 }
18832 {
18833 PyThreadState* __tstate = wxPyBeginAllowThreads();
18834 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18835
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 {
18840 resultobj = SWIG_From_int((int)(result));
18841 }
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18849 PyObject *resultobj;
18850 wxDateTime::Month arg1 ;
18851 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18852 wxString result;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 char *kwnames[] = {
18856 (char *) "month",(char *) "flags", NULL
18857 };
18858
18859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18860 {
18861 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 }
18864 if (obj1) {
18865 {
18866 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18867 if (SWIG_arg_fail(2)) SWIG_fail;
18868 }
18869 }
18870 {
18871 PyThreadState* __tstate = wxPyBeginAllowThreads();
18872 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18873
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 {
18878 #if wxUSE_UNICODE
18879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18880 #else
18881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18882 #endif
18883 }
18884 return resultobj;
18885 fail:
18886 return NULL;
18887 }
18888
18889
18890 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18891 PyObject *resultobj;
18892 wxDateTime::WeekDay arg1 ;
18893 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18894 wxString result;
18895 PyObject * obj0 = 0 ;
18896 PyObject * obj1 = 0 ;
18897 char *kwnames[] = {
18898 (char *) "weekday",(char *) "flags", NULL
18899 };
18900
18901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18902 {
18903 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18904 if (SWIG_arg_fail(1)) SWIG_fail;
18905 }
18906 if (obj1) {
18907 {
18908 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18909 if (SWIG_arg_fail(2)) SWIG_fail;
18910 }
18911 }
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18915
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 {
18920 #if wxUSE_UNICODE
18921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18922 #else
18923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18924 #endif
18925 }
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxString *arg1 = (wxString *) 0 ;
18935 wxString *arg2 = (wxString *) 0 ;
18936 bool temp1 = false ;
18937 bool temp2 = false ;
18938 PyObject * obj0 = 0 ;
18939 PyObject * obj1 = 0 ;
18940 char *kwnames[] = {
18941 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18942 };
18943
18944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18945 {
18946 arg1 = wxString_in_helper(obj0);
18947 if (arg1 == NULL) SWIG_fail;
18948 temp1 = true;
18949 }
18950 {
18951 arg2 = wxString_in_helper(obj1);
18952 if (arg2 == NULL) SWIG_fail;
18953 temp2 = true;
18954 }
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 wxDateTime::GetAmPmStrings(arg1,arg2);
18958
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 Py_INCREF(Py_None); resultobj = Py_None;
18963 {
18964 if (temp1)
18965 delete arg1;
18966 }
18967 {
18968 if (temp2)
18969 delete arg2;
18970 }
18971 return resultobj;
18972 fail:
18973 {
18974 if (temp1)
18975 delete arg1;
18976 }
18977 {
18978 if (temp2)
18979 delete arg2;
18980 }
18981 return NULL;
18982 }
18983
18984
18985 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj;
18987 int arg1 = (int) wxDateTime::Inv_Year ;
18988 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
18989 bool result;
18990 PyObject * obj0 = 0 ;
18991 PyObject * obj1 = 0 ;
18992 char *kwnames[] = {
18993 (char *) "year",(char *) "country", NULL
18994 };
18995
18996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
18997 if (obj0) {
18998 {
18999 arg1 = (int)(SWIG_As_int(obj0));
19000 if (SWIG_arg_fail(1)) SWIG_fail;
19001 }
19002 }
19003 if (obj1) {
19004 {
19005 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19006 if (SWIG_arg_fail(2)) SWIG_fail;
19007 }
19008 }
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19012
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 {
19017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19018 }
19019 return resultobj;
19020 fail:
19021 return NULL;
19022 }
19023
19024
19025 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19026 PyObject *resultobj;
19027 int arg1 = (int) wxDateTime::Inv_Year ;
19028 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19029 wxDateTime result;
19030 PyObject * obj0 = 0 ;
19031 PyObject * obj1 = 0 ;
19032 char *kwnames[] = {
19033 (char *) "year",(char *) "country", NULL
19034 };
19035
19036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19037 if (obj0) {
19038 {
19039 arg1 = (int)(SWIG_As_int(obj0));
19040 if (SWIG_arg_fail(1)) SWIG_fail;
19041 }
19042 }
19043 if (obj1) {
19044 {
19045 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19046 if (SWIG_arg_fail(2)) SWIG_fail;
19047 }
19048 }
19049 {
19050 PyThreadState* __tstate = wxPyBeginAllowThreads();
19051 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19052
19053 wxPyEndAllowThreads(__tstate);
19054 if (PyErr_Occurred()) SWIG_fail;
19055 }
19056 {
19057 wxDateTime * resultptr;
19058 resultptr = new wxDateTime((wxDateTime &)(result));
19059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19060 }
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19068 PyObject *resultobj;
19069 int arg1 = (int) wxDateTime::Inv_Year ;
19070 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19071 wxDateTime result;
19072 PyObject * obj0 = 0 ;
19073 PyObject * obj1 = 0 ;
19074 char *kwnames[] = {
19075 (char *) "year",(char *) "country", NULL
19076 };
19077
19078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19079 if (obj0) {
19080 {
19081 arg1 = (int)(SWIG_As_int(obj0));
19082 if (SWIG_arg_fail(1)) SWIG_fail;
19083 }
19084 }
19085 if (obj1) {
19086 {
19087 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19088 if (SWIG_arg_fail(2)) SWIG_fail;
19089 }
19090 }
19091 {
19092 PyThreadState* __tstate = wxPyBeginAllowThreads();
19093 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19094
19095 wxPyEndAllowThreads(__tstate);
19096 if (PyErr_Occurred()) SWIG_fail;
19097 }
19098 {
19099 wxDateTime * resultptr;
19100 resultptr = new wxDateTime((wxDateTime &)(result));
19101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19102 }
19103 return resultobj;
19104 fail:
19105 return NULL;
19106 }
19107
19108
19109 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19110 PyObject *resultobj;
19111 wxDateTime result;
19112 char *kwnames[] = {
19113 NULL
19114 };
19115
19116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19117 {
19118 PyThreadState* __tstate = wxPyBeginAllowThreads();
19119 result = wxDateTime::Now();
19120
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 {
19125 wxDateTime * resultptr;
19126 resultptr = new wxDateTime((wxDateTime &)(result));
19127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19128 }
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19136 PyObject *resultobj;
19137 wxDateTime result;
19138 char *kwnames[] = {
19139 NULL
19140 };
19141
19142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19143 {
19144 PyThreadState* __tstate = wxPyBeginAllowThreads();
19145 result = wxDateTime::UNow();
19146
19147 wxPyEndAllowThreads(__tstate);
19148 if (PyErr_Occurred()) SWIG_fail;
19149 }
19150 {
19151 wxDateTime * resultptr;
19152 resultptr = new wxDateTime((wxDateTime &)(result));
19153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19154 }
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj;
19163 wxDateTime result;
19164 char *kwnames[] = {
19165 NULL
19166 };
19167
19168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19169 {
19170 PyThreadState* __tstate = wxPyBeginAllowThreads();
19171 result = wxDateTime::Today();
19172
19173 wxPyEndAllowThreads(__tstate);
19174 if (PyErr_Occurred()) SWIG_fail;
19175 }
19176 {
19177 wxDateTime * resultptr;
19178 resultptr = new wxDateTime((wxDateTime &)(result));
19179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19180 }
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19188 PyObject *resultobj;
19189 wxDateTime *result;
19190 char *kwnames[] = {
19191 NULL
19192 };
19193
19194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (wxDateTime *)new wxDateTime();
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj;
19211 time_t arg1 ;
19212 wxDateTime *result;
19213 PyObject * obj0 = 0 ;
19214 char *kwnames[] = {
19215 (char *) "timet", NULL
19216 };
19217
19218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19219 {
19220 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19221 if (SWIG_arg_fail(1)) SWIG_fail;
19222 }
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 result = (wxDateTime *)new wxDateTime(arg1);
19226
19227 wxPyEndAllowThreads(__tstate);
19228 if (PyErr_Occurred()) SWIG_fail;
19229 }
19230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19238 PyObject *resultobj;
19239 double arg1 ;
19240 wxDateTime *result;
19241 PyObject * obj0 = 0 ;
19242 char *kwnames[] = {
19243 (char *) "jdn", NULL
19244 };
19245
19246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19247 {
19248 arg1 = (double)(SWIG_As_double(obj0));
19249 if (SWIG_arg_fail(1)) SWIG_fail;
19250 }
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = (wxDateTime *)new wxDateTime(arg1);
19254
19255 wxPyEndAllowThreads(__tstate);
19256 if (PyErr_Occurred()) SWIG_fail;
19257 }
19258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19259 return resultobj;
19260 fail:
19261 return NULL;
19262 }
19263
19264
19265 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19266 PyObject *resultobj;
19267 int arg1 ;
19268 int arg2 = (int) 0 ;
19269 int arg3 = (int) 0 ;
19270 int arg4 = (int) 0 ;
19271 wxDateTime *result;
19272 PyObject * obj0 = 0 ;
19273 PyObject * obj1 = 0 ;
19274 PyObject * obj2 = 0 ;
19275 PyObject * obj3 = 0 ;
19276 char *kwnames[] = {
19277 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19278 };
19279
19280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19281 {
19282 arg1 = (int)(SWIG_As_int(obj0));
19283 if (SWIG_arg_fail(1)) SWIG_fail;
19284 }
19285 if (obj1) {
19286 {
19287 arg2 = (int)(SWIG_As_int(obj1));
19288 if (SWIG_arg_fail(2)) SWIG_fail;
19289 }
19290 }
19291 if (obj2) {
19292 {
19293 arg3 = (int)(SWIG_As_int(obj2));
19294 if (SWIG_arg_fail(3)) SWIG_fail;
19295 }
19296 }
19297 if (obj3) {
19298 {
19299 arg4 = (int)(SWIG_As_int(obj3));
19300 if (SWIG_arg_fail(4)) SWIG_fail;
19301 }
19302 }
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19306
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19318 PyObject *resultobj;
19319 int arg1 ;
19320 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19321 int arg3 = (int) wxDateTime::Inv_Year ;
19322 int arg4 = (int) 0 ;
19323 int arg5 = (int) 0 ;
19324 int arg6 = (int) 0 ;
19325 int arg7 = (int) 0 ;
19326 wxDateTime *result;
19327 PyObject * obj0 = 0 ;
19328 PyObject * obj1 = 0 ;
19329 PyObject * obj2 = 0 ;
19330 PyObject * obj3 = 0 ;
19331 PyObject * obj4 = 0 ;
19332 PyObject * obj5 = 0 ;
19333 PyObject * obj6 = 0 ;
19334 char *kwnames[] = {
19335 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19336 };
19337
19338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19339 {
19340 arg1 = (int)(SWIG_As_int(obj0));
19341 if (SWIG_arg_fail(1)) SWIG_fail;
19342 }
19343 if (obj1) {
19344 {
19345 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19346 if (SWIG_arg_fail(2)) SWIG_fail;
19347 }
19348 }
19349 if (obj2) {
19350 {
19351 arg3 = (int)(SWIG_As_int(obj2));
19352 if (SWIG_arg_fail(3)) SWIG_fail;
19353 }
19354 }
19355 if (obj3) {
19356 {
19357 arg4 = (int)(SWIG_As_int(obj3));
19358 if (SWIG_arg_fail(4)) SWIG_fail;
19359 }
19360 }
19361 if (obj4) {
19362 {
19363 arg5 = (int)(SWIG_As_int(obj4));
19364 if (SWIG_arg_fail(5)) SWIG_fail;
19365 }
19366 }
19367 if (obj5) {
19368 {
19369 arg6 = (int)(SWIG_As_int(obj5));
19370 if (SWIG_arg_fail(6)) SWIG_fail;
19371 }
19372 }
19373 if (obj6) {
19374 {
19375 arg7 = (int)(SWIG_As_int(obj6));
19376 if (SWIG_arg_fail(7)) SWIG_fail;
19377 }
19378 }
19379 {
19380 PyThreadState* __tstate = wxPyBeginAllowThreads();
19381 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19382
19383 wxPyEndAllowThreads(__tstate);
19384 if (PyErr_Occurred()) SWIG_fail;
19385 }
19386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19387 return resultobj;
19388 fail:
19389 return NULL;
19390 }
19391
19392
19393 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19394 PyObject *resultobj;
19395 wxDateTime *arg1 = (wxDateTime *) 0 ;
19396 PyObject * obj0 = 0 ;
19397 char *kwnames[] = {
19398 (char *) "self", NULL
19399 };
19400
19401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19403 if (SWIG_arg_fail(1)) SWIG_fail;
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 delete arg1;
19407
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 Py_INCREF(Py_None); resultobj = Py_None;
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj;
19420 wxDateTime *arg1 = (wxDateTime *) 0 ;
19421 wxDateTime *result;
19422 PyObject * obj0 = 0 ;
19423 char *kwnames[] = {
19424 (char *) "self", NULL
19425 };
19426
19427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19429 if (SWIG_arg_fail(1)) SWIG_fail;
19430 {
19431 PyThreadState* __tstate = wxPyBeginAllowThreads();
19432 {
19433 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19434 result = (wxDateTime *) &_result_ref;
19435 }
19436
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj;
19449 wxDateTime *arg1 = (wxDateTime *) 0 ;
19450 time_t arg2 ;
19451 wxDateTime *result;
19452 PyObject * obj0 = 0 ;
19453 PyObject * obj1 = 0 ;
19454 char *kwnames[] = {
19455 (char *) "self",(char *) "timet", NULL
19456 };
19457
19458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19460 if (SWIG_arg_fail(1)) SWIG_fail;
19461 {
19462 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19463 if (SWIG_arg_fail(2)) SWIG_fail;
19464 }
19465 {
19466 PyThreadState* __tstate = wxPyBeginAllowThreads();
19467 {
19468 wxDateTime &_result_ref = (arg1)->Set(arg2);
19469 result = (wxDateTime *) &_result_ref;
19470 }
19471
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19476 return resultobj;
19477 fail:
19478 return NULL;
19479 }
19480
19481
19482 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19483 PyObject *resultobj;
19484 wxDateTime *arg1 = (wxDateTime *) 0 ;
19485 double arg2 ;
19486 wxDateTime *result;
19487 PyObject * obj0 = 0 ;
19488 PyObject * obj1 = 0 ;
19489 char *kwnames[] = {
19490 (char *) "self",(char *) "jdn", NULL
19491 };
19492
19493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19495 if (SWIG_arg_fail(1)) SWIG_fail;
19496 {
19497 arg2 = (double)(SWIG_As_double(obj1));
19498 if (SWIG_arg_fail(2)) SWIG_fail;
19499 }
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 {
19503 wxDateTime &_result_ref = (arg1)->Set(arg2);
19504 result = (wxDateTime *) &_result_ref;
19505 }
19506
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19518 PyObject *resultobj;
19519 wxDateTime *arg1 = (wxDateTime *) 0 ;
19520 int arg2 ;
19521 int arg3 = (int) 0 ;
19522 int arg4 = (int) 0 ;
19523 int arg5 = (int) 0 ;
19524 wxDateTime *result;
19525 PyObject * obj0 = 0 ;
19526 PyObject * obj1 = 0 ;
19527 PyObject * obj2 = 0 ;
19528 PyObject * obj3 = 0 ;
19529 PyObject * obj4 = 0 ;
19530 char *kwnames[] = {
19531 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19532 };
19533
19534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19536 if (SWIG_arg_fail(1)) SWIG_fail;
19537 {
19538 arg2 = (int)(SWIG_As_int(obj1));
19539 if (SWIG_arg_fail(2)) SWIG_fail;
19540 }
19541 if (obj2) {
19542 {
19543 arg3 = (int)(SWIG_As_int(obj2));
19544 if (SWIG_arg_fail(3)) SWIG_fail;
19545 }
19546 }
19547 if (obj3) {
19548 {
19549 arg4 = (int)(SWIG_As_int(obj3));
19550 if (SWIG_arg_fail(4)) SWIG_fail;
19551 }
19552 }
19553 if (obj4) {
19554 {
19555 arg5 = (int)(SWIG_As_int(obj4));
19556 if (SWIG_arg_fail(5)) SWIG_fail;
19557 }
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 {
19562 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19563 result = (wxDateTime *) &_result_ref;
19564 }
19565
19566 wxPyEndAllowThreads(__tstate);
19567 if (PyErr_Occurred()) SWIG_fail;
19568 }
19569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19577 PyObject *resultobj;
19578 wxDateTime *arg1 = (wxDateTime *) 0 ;
19579 int arg2 ;
19580 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19581 int arg4 = (int) wxDateTime::Inv_Year ;
19582 int arg5 = (int) 0 ;
19583 int arg6 = (int) 0 ;
19584 int arg7 = (int) 0 ;
19585 int arg8 = (int) 0 ;
19586 wxDateTime *result;
19587 PyObject * obj0 = 0 ;
19588 PyObject * obj1 = 0 ;
19589 PyObject * obj2 = 0 ;
19590 PyObject * obj3 = 0 ;
19591 PyObject * obj4 = 0 ;
19592 PyObject * obj5 = 0 ;
19593 PyObject * obj6 = 0 ;
19594 PyObject * obj7 = 0 ;
19595 char *kwnames[] = {
19596 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19597 };
19598
19599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19601 if (SWIG_arg_fail(1)) SWIG_fail;
19602 {
19603 arg2 = (int)(SWIG_As_int(obj1));
19604 if (SWIG_arg_fail(2)) SWIG_fail;
19605 }
19606 if (obj2) {
19607 {
19608 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19609 if (SWIG_arg_fail(3)) SWIG_fail;
19610 }
19611 }
19612 if (obj3) {
19613 {
19614 arg4 = (int)(SWIG_As_int(obj3));
19615 if (SWIG_arg_fail(4)) SWIG_fail;
19616 }
19617 }
19618 if (obj4) {
19619 {
19620 arg5 = (int)(SWIG_As_int(obj4));
19621 if (SWIG_arg_fail(5)) SWIG_fail;
19622 }
19623 }
19624 if (obj5) {
19625 {
19626 arg6 = (int)(SWIG_As_int(obj5));
19627 if (SWIG_arg_fail(6)) SWIG_fail;
19628 }
19629 }
19630 if (obj6) {
19631 {
19632 arg7 = (int)(SWIG_As_int(obj6));
19633 if (SWIG_arg_fail(7)) SWIG_fail;
19634 }
19635 }
19636 if (obj7) {
19637 {
19638 arg8 = (int)(SWIG_As_int(obj7));
19639 if (SWIG_arg_fail(8)) SWIG_fail;
19640 }
19641 }
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 {
19645 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19646 result = (wxDateTime *) &_result_ref;
19647 }
19648
19649 wxPyEndAllowThreads(__tstate);
19650 if (PyErr_Occurred()) SWIG_fail;
19651 }
19652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19653 return resultobj;
19654 fail:
19655 return NULL;
19656 }
19657
19658
19659 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19660 PyObject *resultobj;
19661 wxDateTime *arg1 = (wxDateTime *) 0 ;
19662 wxDateTime *result;
19663 PyObject * obj0 = 0 ;
19664 char *kwnames[] = {
19665 (char *) "self", NULL
19666 };
19667
19668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19670 if (SWIG_arg_fail(1)) SWIG_fail;
19671 {
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 {
19674 wxDateTime &_result_ref = (arg1)->ResetTime();
19675 result = (wxDateTime *) &_result_ref;
19676 }
19677
19678 wxPyEndAllowThreads(__tstate);
19679 if (PyErr_Occurred()) SWIG_fail;
19680 }
19681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19682 return resultobj;
19683 fail:
19684 return NULL;
19685 }
19686
19687
19688 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19689 PyObject *resultobj;
19690 wxDateTime *arg1 = (wxDateTime *) 0 ;
19691 int arg2 ;
19692 wxDateTime *result;
19693 PyObject * obj0 = 0 ;
19694 PyObject * obj1 = 0 ;
19695 char *kwnames[] = {
19696 (char *) "self",(char *) "year", NULL
19697 };
19698
19699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19701 if (SWIG_arg_fail(1)) SWIG_fail;
19702 {
19703 arg2 = (int)(SWIG_As_int(obj1));
19704 if (SWIG_arg_fail(2)) SWIG_fail;
19705 }
19706 {
19707 PyThreadState* __tstate = wxPyBeginAllowThreads();
19708 {
19709 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19710 result = (wxDateTime *) &_result_ref;
19711 }
19712
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj;
19725 wxDateTime *arg1 = (wxDateTime *) 0 ;
19726 wxDateTime::Month arg2 ;
19727 wxDateTime *result;
19728 PyObject * obj0 = 0 ;
19729 PyObject * obj1 = 0 ;
19730 char *kwnames[] = {
19731 (char *) "self",(char *) "month", NULL
19732 };
19733
19734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19736 if (SWIG_arg_fail(1)) SWIG_fail;
19737 {
19738 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19739 if (SWIG_arg_fail(2)) SWIG_fail;
19740 }
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 {
19744 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19745 result = (wxDateTime *) &_result_ref;
19746 }
19747
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19759 PyObject *resultobj;
19760 wxDateTime *arg1 = (wxDateTime *) 0 ;
19761 int arg2 ;
19762 wxDateTime *result;
19763 PyObject * obj0 = 0 ;
19764 PyObject * obj1 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self",(char *) "day", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 {
19773 arg2 = (int)(SWIG_As_int(obj1));
19774 if (SWIG_arg_fail(2)) SWIG_fail;
19775 }
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 {
19779 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19780 result = (wxDateTime *) &_result_ref;
19781 }
19782
19783 wxPyEndAllowThreads(__tstate);
19784 if (PyErr_Occurred()) SWIG_fail;
19785 }
19786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19794 PyObject *resultobj;
19795 wxDateTime *arg1 = (wxDateTime *) 0 ;
19796 int arg2 ;
19797 wxDateTime *result;
19798 PyObject * obj0 = 0 ;
19799 PyObject * obj1 = 0 ;
19800 char *kwnames[] = {
19801 (char *) "self",(char *) "hour", NULL
19802 };
19803
19804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19806 if (SWIG_arg_fail(1)) SWIG_fail;
19807 {
19808 arg2 = (int)(SWIG_As_int(obj1));
19809 if (SWIG_arg_fail(2)) SWIG_fail;
19810 }
19811 {
19812 PyThreadState* __tstate = wxPyBeginAllowThreads();
19813 {
19814 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19815 result = (wxDateTime *) &_result_ref;
19816 }
19817
19818 wxPyEndAllowThreads(__tstate);
19819 if (PyErr_Occurred()) SWIG_fail;
19820 }
19821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19822 return resultobj;
19823 fail:
19824 return NULL;
19825 }
19826
19827
19828 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19829 PyObject *resultobj;
19830 wxDateTime *arg1 = (wxDateTime *) 0 ;
19831 int arg2 ;
19832 wxDateTime *result;
19833 PyObject * obj0 = 0 ;
19834 PyObject * obj1 = 0 ;
19835 char *kwnames[] = {
19836 (char *) "self",(char *) "minute", NULL
19837 };
19838
19839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19841 if (SWIG_arg_fail(1)) SWIG_fail;
19842 {
19843 arg2 = (int)(SWIG_As_int(obj1));
19844 if (SWIG_arg_fail(2)) SWIG_fail;
19845 }
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 {
19849 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19850 result = (wxDateTime *) &_result_ref;
19851 }
19852
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj;
19865 wxDateTime *arg1 = (wxDateTime *) 0 ;
19866 int arg2 ;
19867 wxDateTime *result;
19868 PyObject * obj0 = 0 ;
19869 PyObject * obj1 = 0 ;
19870 char *kwnames[] = {
19871 (char *) "self",(char *) "second", NULL
19872 };
19873
19874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19876 if (SWIG_arg_fail(1)) SWIG_fail;
19877 {
19878 arg2 = (int)(SWIG_As_int(obj1));
19879 if (SWIG_arg_fail(2)) SWIG_fail;
19880 }
19881 {
19882 PyThreadState* __tstate = wxPyBeginAllowThreads();
19883 {
19884 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
19885 result = (wxDateTime *) &_result_ref;
19886 }
19887
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj;
19900 wxDateTime *arg1 = (wxDateTime *) 0 ;
19901 int arg2 ;
19902 wxDateTime *result;
19903 PyObject * obj0 = 0 ;
19904 PyObject * obj1 = 0 ;
19905 char *kwnames[] = {
19906 (char *) "self",(char *) "millisecond", NULL
19907 };
19908
19909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19911 if (SWIG_arg_fail(1)) SWIG_fail;
19912 {
19913 arg2 = (int)(SWIG_As_int(obj1));
19914 if (SWIG_arg_fail(2)) SWIG_fail;
19915 }
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 {
19919 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19920 result = (wxDateTime *) &_result_ref;
19921 }
19922
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj;
19935 wxDateTime *arg1 = (wxDateTime *) 0 ;
19936 wxDateTime::WeekDay arg2 ;
19937 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19938 wxDateTime *result;
19939 PyObject * obj0 = 0 ;
19940 PyObject * obj1 = 0 ;
19941 PyObject * obj2 = 0 ;
19942 char *kwnames[] = {
19943 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19944 };
19945
19946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19948 if (SWIG_arg_fail(1)) SWIG_fail;
19949 {
19950 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19951 if (SWIG_arg_fail(2)) SWIG_fail;
19952 }
19953 if (obj2) {
19954 {
19955 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19956 if (SWIG_arg_fail(3)) SWIG_fail;
19957 }
19958 }
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 {
19962 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19963 result = (wxDateTime *) &_result_ref;
19964 }
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj;
19978 wxDateTime *arg1 = (wxDateTime *) 0 ;
19979 wxDateTime::WeekDay arg2 ;
19980 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19981 wxDateTime result;
19982 PyObject * obj0 = 0 ;
19983 PyObject * obj1 = 0 ;
19984 PyObject * obj2 = 0 ;
19985 char *kwnames[] = {
19986 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19987 };
19988
19989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19991 if (SWIG_arg_fail(1)) SWIG_fail;
19992 {
19993 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19994 if (SWIG_arg_fail(2)) SWIG_fail;
19995 }
19996 if (obj2) {
19997 {
19998 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19999 if (SWIG_arg_fail(3)) SWIG_fail;
20000 }
20001 }
20002 {
20003 PyThreadState* __tstate = wxPyBeginAllowThreads();
20004 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20005
20006 wxPyEndAllowThreads(__tstate);
20007 if (PyErr_Occurred()) SWIG_fail;
20008 }
20009 {
20010 wxDateTime * resultptr;
20011 resultptr = new wxDateTime((wxDateTime &)(result));
20012 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20013 }
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj;
20022 wxDateTime *arg1 = (wxDateTime *) 0 ;
20023 wxDateTime::WeekDay arg2 ;
20024 wxDateTime *result;
20025 PyObject * obj0 = 0 ;
20026 PyObject * obj1 = 0 ;
20027 char *kwnames[] = {
20028 (char *) "self",(char *) "weekday", NULL
20029 };
20030
20031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20033 if (SWIG_arg_fail(1)) SWIG_fail;
20034 {
20035 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20036 if (SWIG_arg_fail(2)) SWIG_fail;
20037 }
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 {
20041 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20042 result = (wxDateTime *) &_result_ref;
20043 }
20044
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20049 return resultobj;
20050 fail:
20051 return NULL;
20052 }
20053
20054
20055 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20056 PyObject *resultobj;
20057 wxDateTime *arg1 = (wxDateTime *) 0 ;
20058 wxDateTime::WeekDay arg2 ;
20059 wxDateTime result;
20060 PyObject * obj0 = 0 ;
20061 PyObject * obj1 = 0 ;
20062 char *kwnames[] = {
20063 (char *) "self",(char *) "weekday", NULL
20064 };
20065
20066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20068 if (SWIG_arg_fail(1)) SWIG_fail;
20069 {
20070 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20071 if (SWIG_arg_fail(2)) SWIG_fail;
20072 }
20073 {
20074 PyThreadState* __tstate = wxPyBeginAllowThreads();
20075 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20076
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 {
20081 wxDateTime * resultptr;
20082 resultptr = new wxDateTime((wxDateTime &)(result));
20083 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20084 }
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20092 PyObject *resultobj;
20093 wxDateTime *arg1 = (wxDateTime *) 0 ;
20094 wxDateTime::WeekDay arg2 ;
20095 wxDateTime *result;
20096 PyObject * obj0 = 0 ;
20097 PyObject * obj1 = 0 ;
20098 char *kwnames[] = {
20099 (char *) "self",(char *) "weekday", NULL
20100 };
20101
20102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20104 if (SWIG_arg_fail(1)) SWIG_fail;
20105 {
20106 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20107 if (SWIG_arg_fail(2)) SWIG_fail;
20108 }
20109 {
20110 PyThreadState* __tstate = wxPyBeginAllowThreads();
20111 {
20112 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20113 result = (wxDateTime *) &_result_ref;
20114 }
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20127 PyObject *resultobj;
20128 wxDateTime *arg1 = (wxDateTime *) 0 ;
20129 wxDateTime::WeekDay arg2 ;
20130 wxDateTime result;
20131 PyObject * obj0 = 0 ;
20132 PyObject * obj1 = 0 ;
20133 char *kwnames[] = {
20134 (char *) "self",(char *) "weekday", NULL
20135 };
20136
20137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20139 if (SWIG_arg_fail(1)) SWIG_fail;
20140 {
20141 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20142 if (SWIG_arg_fail(2)) SWIG_fail;
20143 }
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 wxDateTime * resultptr;
20153 resultptr = new wxDateTime((wxDateTime &)(result));
20154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20155 }
20156 return resultobj;
20157 fail:
20158 return NULL;
20159 }
20160
20161
20162 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20163 PyObject *resultobj;
20164 wxDateTime *arg1 = (wxDateTime *) 0 ;
20165 wxDateTime::WeekDay arg2 ;
20166 int arg3 = (int) 1 ;
20167 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20168 int arg5 = (int) wxDateTime::Inv_Year ;
20169 bool result;
20170 PyObject * obj0 = 0 ;
20171 PyObject * obj1 = 0 ;
20172 PyObject * obj2 = 0 ;
20173 PyObject * obj3 = 0 ;
20174 PyObject * obj4 = 0 ;
20175 char *kwnames[] = {
20176 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20177 };
20178
20179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20181 if (SWIG_arg_fail(1)) SWIG_fail;
20182 {
20183 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20184 if (SWIG_arg_fail(2)) SWIG_fail;
20185 }
20186 if (obj2) {
20187 {
20188 arg3 = (int)(SWIG_As_int(obj2));
20189 if (SWIG_arg_fail(3)) SWIG_fail;
20190 }
20191 }
20192 if (obj3) {
20193 {
20194 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20195 if (SWIG_arg_fail(4)) SWIG_fail;
20196 }
20197 }
20198 if (obj4) {
20199 {
20200 arg5 = (int)(SWIG_As_int(obj4));
20201 if (SWIG_arg_fail(5)) SWIG_fail;
20202 }
20203 }
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20207
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 {
20212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20213 }
20214 return resultobj;
20215 fail:
20216 return NULL;
20217 }
20218
20219
20220 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20221 PyObject *resultobj;
20222 wxDateTime *arg1 = (wxDateTime *) 0 ;
20223 wxDateTime::WeekDay arg2 ;
20224 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20225 int arg4 = (int) wxDateTime::Inv_Year ;
20226 bool result;
20227 PyObject * obj0 = 0 ;
20228 PyObject * obj1 = 0 ;
20229 PyObject * obj2 = 0 ;
20230 PyObject * obj3 = 0 ;
20231 char *kwnames[] = {
20232 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20233 };
20234
20235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20237 if (SWIG_arg_fail(1)) SWIG_fail;
20238 {
20239 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20240 if (SWIG_arg_fail(2)) SWIG_fail;
20241 }
20242 if (obj2) {
20243 {
20244 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20245 if (SWIG_arg_fail(3)) SWIG_fail;
20246 }
20247 }
20248 if (obj3) {
20249 {
20250 arg4 = (int)(SWIG_As_int(obj3));
20251 if (SWIG_arg_fail(4)) SWIG_fail;
20252 }
20253 }
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20257
20258 wxPyEndAllowThreads(__tstate);
20259 if (PyErr_Occurred()) SWIG_fail;
20260 }
20261 {
20262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20263 }
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20271 PyObject *resultobj;
20272 wxDateTime *arg1 = (wxDateTime *) 0 ;
20273 wxDateTime::WeekDay arg2 ;
20274 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20275 int arg4 = (int) wxDateTime::Inv_Year ;
20276 wxDateTime result;
20277 PyObject * obj0 = 0 ;
20278 PyObject * obj1 = 0 ;
20279 PyObject * obj2 = 0 ;
20280 PyObject * obj3 = 0 ;
20281 char *kwnames[] = {
20282 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20283 };
20284
20285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20287 if (SWIG_arg_fail(1)) SWIG_fail;
20288 {
20289 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20290 if (SWIG_arg_fail(2)) SWIG_fail;
20291 }
20292 if (obj2) {
20293 {
20294 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20295 if (SWIG_arg_fail(3)) SWIG_fail;
20296 }
20297 }
20298 if (obj3) {
20299 {
20300 arg4 = (int)(SWIG_As_int(obj3));
20301 if (SWIG_arg_fail(4)) SWIG_fail;
20302 }
20303 }
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20307
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 {
20312 wxDateTime * resultptr;
20313 resultptr = new wxDateTime((wxDateTime &)(result));
20314 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20315 }
20316 return resultobj;
20317 fail:
20318 return NULL;
20319 }
20320
20321
20322 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20323 PyObject *resultobj;
20324 wxDateTime *arg1 = (wxDateTime *) 0 ;
20325 int arg2 ;
20326 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20327 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20328 bool result;
20329 PyObject * obj0 = 0 ;
20330 PyObject * obj1 = 0 ;
20331 PyObject * obj2 = 0 ;
20332 PyObject * obj3 = 0 ;
20333 char *kwnames[] = {
20334 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20335 };
20336
20337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20339 if (SWIG_arg_fail(1)) SWIG_fail;
20340 {
20341 arg2 = (int)(SWIG_As_int(obj1));
20342 if (SWIG_arg_fail(2)) SWIG_fail;
20343 }
20344 if (obj2) {
20345 {
20346 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20347 if (SWIG_arg_fail(3)) SWIG_fail;
20348 }
20349 }
20350 if (obj3) {
20351 {
20352 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20353 if (SWIG_arg_fail(4)) SWIG_fail;
20354 }
20355 }
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20359
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 {
20364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20365 }
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj;
20374 wxDateTime *arg1 = (wxDateTime *) 0 ;
20375 int arg2 ;
20376 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20377 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20378 wxDateTime result;
20379 PyObject * obj0 = 0 ;
20380 PyObject * obj1 = 0 ;
20381 PyObject * obj2 = 0 ;
20382 PyObject * obj3 = 0 ;
20383 char *kwnames[] = {
20384 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20385 };
20386
20387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20389 if (SWIG_arg_fail(1)) SWIG_fail;
20390 {
20391 arg2 = (int)(SWIG_As_int(obj1));
20392 if (SWIG_arg_fail(2)) SWIG_fail;
20393 }
20394 if (obj2) {
20395 {
20396 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20397 if (SWIG_arg_fail(3)) SWIG_fail;
20398 }
20399 }
20400 if (obj3) {
20401 {
20402 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20403 if (SWIG_arg_fail(4)) SWIG_fail;
20404 }
20405 }
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20409
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 {
20414 wxDateTime * resultptr;
20415 resultptr = new wxDateTime((wxDateTime &)(result));
20416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20417 }
20418 return resultobj;
20419 fail:
20420 return NULL;
20421 }
20422
20423
20424 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj;
20426 int arg1 ;
20427 int arg2 ;
20428 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20429 wxDateTime result;
20430 PyObject * obj0 = 0 ;
20431 PyObject * obj1 = 0 ;
20432 PyObject * obj2 = 0 ;
20433 char *kwnames[] = {
20434 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20435 };
20436
20437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20438 {
20439 arg1 = (int)(SWIG_As_int(obj0));
20440 if (SWIG_arg_fail(1)) SWIG_fail;
20441 }
20442 {
20443 arg2 = (int)(SWIG_As_int(obj1));
20444 if (SWIG_arg_fail(2)) SWIG_fail;
20445 }
20446 if (obj2) {
20447 {
20448 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20449 if (SWIG_arg_fail(3)) SWIG_fail;
20450 }
20451 }
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20455
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 {
20460 wxDateTime * resultptr;
20461 resultptr = new wxDateTime((wxDateTime &)(result));
20462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20463 }
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20471 PyObject *resultobj;
20472 wxDateTime *arg1 = (wxDateTime *) 0 ;
20473 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20474 int arg3 = (int) wxDateTime::Inv_Year ;
20475 wxDateTime *result;
20476 PyObject * obj0 = 0 ;
20477 PyObject * obj1 = 0 ;
20478 PyObject * obj2 = 0 ;
20479 char *kwnames[] = {
20480 (char *) "self",(char *) "month",(char *) "year", NULL
20481 };
20482
20483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20485 if (SWIG_arg_fail(1)) SWIG_fail;
20486 if (obj1) {
20487 {
20488 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20489 if (SWIG_arg_fail(2)) SWIG_fail;
20490 }
20491 }
20492 if (obj2) {
20493 {
20494 arg3 = (int)(SWIG_As_int(obj2));
20495 if (SWIG_arg_fail(3)) SWIG_fail;
20496 }
20497 }
20498 {
20499 PyThreadState* __tstate = wxPyBeginAllowThreads();
20500 {
20501 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20502 result = (wxDateTime *) &_result_ref;
20503 }
20504
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20509 return resultobj;
20510 fail:
20511 return NULL;
20512 }
20513
20514
20515 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20516 PyObject *resultobj;
20517 wxDateTime *arg1 = (wxDateTime *) 0 ;
20518 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20519 int arg3 = (int) wxDateTime::Inv_Year ;
20520 wxDateTime result;
20521 PyObject * obj0 = 0 ;
20522 PyObject * obj1 = 0 ;
20523 PyObject * obj2 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "self",(char *) "month",(char *) "year", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 if (obj1) {
20532 {
20533 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20534 if (SWIG_arg_fail(2)) SWIG_fail;
20535 }
20536 }
20537 if (obj2) {
20538 {
20539 arg3 = (int)(SWIG_As_int(obj2));
20540 if (SWIG_arg_fail(3)) SWIG_fail;
20541 }
20542 }
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20546
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 {
20551 wxDateTime * resultptr;
20552 resultptr = new wxDateTime((wxDateTime &)(result));
20553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20554 }
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20562 PyObject *resultobj;
20563 wxDateTime *arg1 = (wxDateTime *) 0 ;
20564 int arg2 ;
20565 wxDateTime *result;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "self",(char *) "yday", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20574 if (SWIG_arg_fail(1)) SWIG_fail;
20575 {
20576 arg2 = (int)(SWIG_As_int(obj1));
20577 if (SWIG_arg_fail(2)) SWIG_fail;
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 {
20582 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20583 result = (wxDateTime *) &_result_ref;
20584 }
20585
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj;
20598 wxDateTime *arg1 = (wxDateTime *) 0 ;
20599 int arg2 ;
20600 wxDateTime result;
20601 PyObject * obj0 = 0 ;
20602 PyObject * obj1 = 0 ;
20603 char *kwnames[] = {
20604 (char *) "self",(char *) "yday", NULL
20605 };
20606
20607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20609 if (SWIG_arg_fail(1)) SWIG_fail;
20610 {
20611 arg2 = (int)(SWIG_As_int(obj1));
20612 if (SWIG_arg_fail(2)) SWIG_fail;
20613 }
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (arg1)->GetYearDay(arg2);
20617
20618 wxPyEndAllowThreads(__tstate);
20619 if (PyErr_Occurred()) SWIG_fail;
20620 }
20621 {
20622 wxDateTime * resultptr;
20623 resultptr = new wxDateTime((wxDateTime &)(result));
20624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20633 PyObject *resultobj;
20634 wxDateTime *arg1 = (wxDateTime *) 0 ;
20635 double result;
20636 PyObject * obj0 = 0 ;
20637 char *kwnames[] = {
20638 (char *) "self", NULL
20639 };
20640
20641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20643 if (SWIG_arg_fail(1)) SWIG_fail;
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (double)(arg1)->GetJulianDayNumber();
20647
20648 wxPyEndAllowThreads(__tstate);
20649 if (PyErr_Occurred()) SWIG_fail;
20650 }
20651 {
20652 resultobj = SWIG_From_double((double)(result));
20653 }
20654 return resultobj;
20655 fail:
20656 return NULL;
20657 }
20658
20659
20660 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20661 PyObject *resultobj;
20662 wxDateTime *arg1 = (wxDateTime *) 0 ;
20663 double result;
20664 PyObject * obj0 = 0 ;
20665 char *kwnames[] = {
20666 (char *) "self", NULL
20667 };
20668
20669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20671 if (SWIG_arg_fail(1)) SWIG_fail;
20672 {
20673 PyThreadState* __tstate = wxPyBeginAllowThreads();
20674 result = (double)(arg1)->GetJDN();
20675
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 {
20680 resultobj = SWIG_From_double((double)(result));
20681 }
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20689 PyObject *resultobj;
20690 wxDateTime *arg1 = (wxDateTime *) 0 ;
20691 double result;
20692 PyObject * obj0 = 0 ;
20693 char *kwnames[] = {
20694 (char *) "self", NULL
20695 };
20696
20697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 resultobj = SWIG_From_double((double)(result));
20709 }
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20717 PyObject *resultobj;
20718 wxDateTime *arg1 = (wxDateTime *) 0 ;
20719 double result;
20720 PyObject * obj0 = 0 ;
20721 char *kwnames[] = {
20722 (char *) "self", NULL
20723 };
20724
20725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20727 if (SWIG_arg_fail(1)) SWIG_fail;
20728 {
20729 PyThreadState* __tstate = wxPyBeginAllowThreads();
20730 result = (double)(arg1)->GetMJD();
20731
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = SWIG_From_double((double)(result));
20737 }
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20745 PyObject *resultobj;
20746 wxDateTime *arg1 = (wxDateTime *) 0 ;
20747 double result;
20748 PyObject * obj0 = 0 ;
20749 char *kwnames[] = {
20750 (char *) "self", NULL
20751 };
20752
20753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20755 if (SWIG_arg_fail(1)) SWIG_fail;
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (double)(arg1)->GetRataDie();
20759
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 {
20764 resultobj = SWIG_From_double((double)(result));
20765 }
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20773 PyObject *resultobj;
20774 wxDateTime *arg1 = (wxDateTime *) 0 ;
20775 wxDateTime::TimeZone *arg2 = 0 ;
20776 bool arg3 = (bool) false ;
20777 wxDateTime result;
20778 bool temp2 = false ;
20779 PyObject * obj0 = 0 ;
20780 PyObject * obj1 = 0 ;
20781 PyObject * obj2 = 0 ;
20782 char *kwnames[] = {
20783 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20784 };
20785
20786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20788 if (SWIG_arg_fail(1)) SWIG_fail;
20789 {
20790 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20791 temp2 = true;
20792 }
20793 if (obj2) {
20794 {
20795 arg3 = (bool)(SWIG_As_bool(obj2));
20796 if (SWIG_arg_fail(3)) SWIG_fail;
20797 }
20798 }
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20802
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 {
20807 wxDateTime * resultptr;
20808 resultptr = new wxDateTime((wxDateTime &)(result));
20809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20810 }
20811 {
20812 if (temp2) delete arg2;
20813 }
20814 return resultobj;
20815 fail:
20816 {
20817 if (temp2) delete arg2;
20818 }
20819 return NULL;
20820 }
20821
20822
20823 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20824 PyObject *resultobj;
20825 wxDateTime *arg1 = (wxDateTime *) 0 ;
20826 wxDateTime::TimeZone *arg2 = 0 ;
20827 bool arg3 = (bool) false ;
20828 wxDateTime *result;
20829 bool temp2 = false ;
20830 PyObject * obj0 = 0 ;
20831 PyObject * obj1 = 0 ;
20832 PyObject * obj2 = 0 ;
20833 char *kwnames[] = {
20834 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20835 };
20836
20837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20839 if (SWIG_arg_fail(1)) SWIG_fail;
20840 {
20841 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20842 temp2 = true;
20843 }
20844 if (obj2) {
20845 {
20846 arg3 = (bool)(SWIG_As_bool(obj2));
20847 if (SWIG_arg_fail(3)) SWIG_fail;
20848 }
20849 }
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 {
20853 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20854 result = (wxDateTime *) &_result_ref;
20855 }
20856
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20861 {
20862 if (temp2) delete arg2;
20863 }
20864 return resultobj;
20865 fail:
20866 {
20867 if (temp2) delete arg2;
20868 }
20869 return NULL;
20870 }
20871
20872
20873 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20874 PyObject *resultobj;
20875 wxDateTime *arg1 = (wxDateTime *) 0 ;
20876 bool arg2 = (bool) false ;
20877 wxDateTime result;
20878 PyObject * obj0 = 0 ;
20879 PyObject * obj1 = 0 ;
20880 char *kwnames[] = {
20881 (char *) "self",(char *) "noDST", NULL
20882 };
20883
20884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20886 if (SWIG_arg_fail(1)) SWIG_fail;
20887 if (obj1) {
20888 {
20889 arg2 = (bool)(SWIG_As_bool(obj1));
20890 if (SWIG_arg_fail(2)) SWIG_fail;
20891 }
20892 }
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (arg1)->ToGMT(arg2);
20896
20897 wxPyEndAllowThreads(__tstate);
20898 if (PyErr_Occurred()) SWIG_fail;
20899 }
20900 {
20901 wxDateTime * resultptr;
20902 resultptr = new wxDateTime((wxDateTime &)(result));
20903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20904 }
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20912 PyObject *resultobj;
20913 wxDateTime *arg1 = (wxDateTime *) 0 ;
20914 bool arg2 = (bool) false ;
20915 wxDateTime *result;
20916 PyObject * obj0 = 0 ;
20917 PyObject * obj1 = 0 ;
20918 char *kwnames[] = {
20919 (char *) "self",(char *) "noDST", NULL
20920 };
20921
20922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20924 if (SWIG_arg_fail(1)) SWIG_fail;
20925 if (obj1) {
20926 {
20927 arg2 = (bool)(SWIG_As_bool(obj1));
20928 if (SWIG_arg_fail(2)) SWIG_fail;
20929 }
20930 }
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 {
20934 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20935 result = (wxDateTime *) &_result_ref;
20936 }
20937
20938 wxPyEndAllowThreads(__tstate);
20939 if (PyErr_Occurred()) SWIG_fail;
20940 }
20941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20949 PyObject *resultobj;
20950 wxDateTime *arg1 = (wxDateTime *) 0 ;
20951 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20952 int result;
20953 PyObject * obj0 = 0 ;
20954 PyObject * obj1 = 0 ;
20955 char *kwnames[] = {
20956 (char *) "self",(char *) "country", NULL
20957 };
20958
20959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20961 if (SWIG_arg_fail(1)) SWIG_fail;
20962 if (obj1) {
20963 {
20964 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20965 if (SWIG_arg_fail(2)) SWIG_fail;
20966 }
20967 }
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 resultobj = SWIG_From_int((int)(result));
20977 }
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
20985 PyObject *resultobj;
20986 wxDateTime *arg1 = (wxDateTime *) 0 ;
20987 bool result;
20988 PyObject * obj0 = 0 ;
20989 char *kwnames[] = {
20990 (char *) "self", NULL
20991 };
20992
20993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
20994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20995 if (SWIG_arg_fail(1)) SWIG_fail;
20996 {
20997 PyThreadState* __tstate = wxPyBeginAllowThreads();
20998 result = (bool)((wxDateTime const *)arg1)->IsValid();
20999
21000 wxPyEndAllowThreads(__tstate);
21001 if (PyErr_Occurred()) SWIG_fail;
21002 }
21003 {
21004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21005 }
21006 return resultobj;
21007 fail:
21008 return NULL;
21009 }
21010
21011
21012 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21013 PyObject *resultobj;
21014 wxDateTime *arg1 = (wxDateTime *) 0 ;
21015 time_t result;
21016 PyObject * obj0 = 0 ;
21017 char *kwnames[] = {
21018 (char *) "self", NULL
21019 };
21020
21021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21023 if (SWIG_arg_fail(1)) SWIG_fail;
21024 {
21025 PyThreadState* __tstate = wxPyBeginAllowThreads();
21026 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21027
21028 wxPyEndAllowThreads(__tstate);
21029 if (PyErr_Occurred()) SWIG_fail;
21030 }
21031 {
21032 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21033 }
21034 return resultobj;
21035 fail:
21036 return NULL;
21037 }
21038
21039
21040 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21041 PyObject *resultobj;
21042 wxDateTime *arg1 = (wxDateTime *) 0 ;
21043 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21044 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21045 int result;
21046 bool temp2 = false ;
21047 PyObject * obj0 = 0 ;
21048 PyObject * obj1 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self",(char *) "tz", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 if (obj1) {
21057 {
21058 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21059 temp2 = true;
21060 }
21061 }
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21065
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 {
21070 resultobj = SWIG_From_int((int)(result));
21071 }
21072 {
21073 if (temp2) delete arg2;
21074 }
21075 return resultobj;
21076 fail:
21077 {
21078 if (temp2) delete arg2;
21079 }
21080 return NULL;
21081 }
21082
21083
21084 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21085 PyObject *resultobj;
21086 wxDateTime *arg1 = (wxDateTime *) 0 ;
21087 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21088 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21089 wxDateTime::Month result;
21090 bool temp2 = false ;
21091 PyObject * obj0 = 0 ;
21092 PyObject * obj1 = 0 ;
21093 char *kwnames[] = {
21094 (char *) "self",(char *) "tz", NULL
21095 };
21096
21097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21099 if (SWIG_arg_fail(1)) SWIG_fail;
21100 if (obj1) {
21101 {
21102 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21103 temp2 = true;
21104 }
21105 }
21106 {
21107 PyThreadState* __tstate = wxPyBeginAllowThreads();
21108 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21109
21110 wxPyEndAllowThreads(__tstate);
21111 if (PyErr_Occurred()) SWIG_fail;
21112 }
21113 resultobj = SWIG_From_int((result));
21114 {
21115 if (temp2) delete arg2;
21116 }
21117 return resultobj;
21118 fail:
21119 {
21120 if (temp2) delete arg2;
21121 }
21122 return NULL;
21123 }
21124
21125
21126 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj;
21128 wxDateTime *arg1 = (wxDateTime *) 0 ;
21129 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21130 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21131 int result;
21132 bool temp2 = false ;
21133 PyObject * obj0 = 0 ;
21134 PyObject * obj1 = 0 ;
21135 char *kwnames[] = {
21136 (char *) "self",(char *) "tz", NULL
21137 };
21138
21139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21141 if (SWIG_arg_fail(1)) SWIG_fail;
21142 if (obj1) {
21143 {
21144 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21145 temp2 = true;
21146 }
21147 }
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21151
21152 wxPyEndAllowThreads(__tstate);
21153 if (PyErr_Occurred()) SWIG_fail;
21154 }
21155 {
21156 resultobj = SWIG_From_int((int)(result));
21157 }
21158 {
21159 if (temp2) delete arg2;
21160 }
21161 return resultobj;
21162 fail:
21163 {
21164 if (temp2) delete arg2;
21165 }
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxDateTime *arg1 = (wxDateTime *) 0 ;
21173 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21174 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21175 wxDateTime::WeekDay result;
21176 bool temp2 = false ;
21177 PyObject * obj0 = 0 ;
21178 PyObject * obj1 = 0 ;
21179 char *kwnames[] = {
21180 (char *) "self",(char *) "tz", NULL
21181 };
21182
21183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21185 if (SWIG_arg_fail(1)) SWIG_fail;
21186 if (obj1) {
21187 {
21188 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21189 temp2 = true;
21190 }
21191 }
21192 {
21193 PyThreadState* __tstate = wxPyBeginAllowThreads();
21194 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21195
21196 wxPyEndAllowThreads(__tstate);
21197 if (PyErr_Occurred()) SWIG_fail;
21198 }
21199 resultobj = SWIG_From_int((result));
21200 {
21201 if (temp2) delete arg2;
21202 }
21203 return resultobj;
21204 fail:
21205 {
21206 if (temp2) delete arg2;
21207 }
21208 return NULL;
21209 }
21210
21211
21212 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21213 PyObject *resultobj;
21214 wxDateTime *arg1 = (wxDateTime *) 0 ;
21215 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21216 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21217 int result;
21218 bool temp2 = false ;
21219 PyObject * obj0 = 0 ;
21220 PyObject * obj1 = 0 ;
21221 char *kwnames[] = {
21222 (char *) "self",(char *) "tz", NULL
21223 };
21224
21225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21227 if (SWIG_arg_fail(1)) SWIG_fail;
21228 if (obj1) {
21229 {
21230 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21231 temp2 = true;
21232 }
21233 }
21234 {
21235 PyThreadState* __tstate = wxPyBeginAllowThreads();
21236 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21237
21238 wxPyEndAllowThreads(__tstate);
21239 if (PyErr_Occurred()) SWIG_fail;
21240 }
21241 {
21242 resultobj = SWIG_From_int((int)(result));
21243 }
21244 {
21245 if (temp2) delete arg2;
21246 }
21247 return resultobj;
21248 fail:
21249 {
21250 if (temp2) delete arg2;
21251 }
21252 return NULL;
21253 }
21254
21255
21256 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21257 PyObject *resultobj;
21258 wxDateTime *arg1 = (wxDateTime *) 0 ;
21259 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21260 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21261 int result;
21262 bool temp2 = false ;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char *kwnames[] = {
21266 (char *) "self",(char *) "tz", NULL
21267 };
21268
21269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21271 if (SWIG_arg_fail(1)) SWIG_fail;
21272 if (obj1) {
21273 {
21274 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21275 temp2 = true;
21276 }
21277 }
21278 {
21279 PyThreadState* __tstate = wxPyBeginAllowThreads();
21280 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21281
21282 wxPyEndAllowThreads(__tstate);
21283 if (PyErr_Occurred()) SWIG_fail;
21284 }
21285 {
21286 resultobj = SWIG_From_int((int)(result));
21287 }
21288 {
21289 if (temp2) delete arg2;
21290 }
21291 return resultobj;
21292 fail:
21293 {
21294 if (temp2) delete arg2;
21295 }
21296 return NULL;
21297 }
21298
21299
21300 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21301 PyObject *resultobj;
21302 wxDateTime *arg1 = (wxDateTime *) 0 ;
21303 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21304 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21305 int result;
21306 bool temp2 = false ;
21307 PyObject * obj0 = 0 ;
21308 PyObject * obj1 = 0 ;
21309 char *kwnames[] = {
21310 (char *) "self",(char *) "tz", NULL
21311 };
21312
21313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21315 if (SWIG_arg_fail(1)) SWIG_fail;
21316 if (obj1) {
21317 {
21318 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21319 temp2 = true;
21320 }
21321 }
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21325
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 {
21330 resultobj = SWIG_From_int((int)(result));
21331 }
21332 {
21333 if (temp2) delete arg2;
21334 }
21335 return resultobj;
21336 fail:
21337 {
21338 if (temp2) delete arg2;
21339 }
21340 return NULL;
21341 }
21342
21343
21344 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21345 PyObject *resultobj;
21346 wxDateTime *arg1 = (wxDateTime *) 0 ;
21347 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21348 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21349 int result;
21350 bool temp2 = false ;
21351 PyObject * obj0 = 0 ;
21352 PyObject * obj1 = 0 ;
21353 char *kwnames[] = {
21354 (char *) "self",(char *) "tz", NULL
21355 };
21356
21357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21359 if (SWIG_arg_fail(1)) SWIG_fail;
21360 if (obj1) {
21361 {
21362 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21363 temp2 = true;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21369
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 {
21374 resultobj = SWIG_From_int((int)(result));
21375 }
21376 {
21377 if (temp2) delete arg2;
21378 }
21379 return resultobj;
21380 fail:
21381 {
21382 if (temp2) delete arg2;
21383 }
21384 return NULL;
21385 }
21386
21387
21388 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21389 PyObject *resultobj;
21390 wxDateTime *arg1 = (wxDateTime *) 0 ;
21391 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21392 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21393 int result;
21394 bool temp2 = false ;
21395 PyObject * obj0 = 0 ;
21396 PyObject * obj1 = 0 ;
21397 char *kwnames[] = {
21398 (char *) "self",(char *) "tz", NULL
21399 };
21400
21401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21403 if (SWIG_arg_fail(1)) SWIG_fail;
21404 if (obj1) {
21405 {
21406 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21407 temp2 = true;
21408 }
21409 }
21410 {
21411 PyThreadState* __tstate = wxPyBeginAllowThreads();
21412 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21413
21414 wxPyEndAllowThreads(__tstate);
21415 if (PyErr_Occurred()) SWIG_fail;
21416 }
21417 {
21418 resultobj = SWIG_From_int((int)(result));
21419 }
21420 {
21421 if (temp2) delete arg2;
21422 }
21423 return resultobj;
21424 fail:
21425 {
21426 if (temp2) delete arg2;
21427 }
21428 return NULL;
21429 }
21430
21431
21432 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21433 PyObject *resultobj;
21434 wxDateTime *arg1 = (wxDateTime *) 0 ;
21435 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21436 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21437 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21438 int result;
21439 bool temp3 = false ;
21440 PyObject * obj0 = 0 ;
21441 PyObject * obj1 = 0 ;
21442 PyObject * obj2 = 0 ;
21443 char *kwnames[] = {
21444 (char *) "self",(char *) "flags",(char *) "tz", NULL
21445 };
21446
21447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21449 if (SWIG_arg_fail(1)) SWIG_fail;
21450 if (obj1) {
21451 {
21452 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21453 if (SWIG_arg_fail(2)) SWIG_fail;
21454 }
21455 }
21456 if (obj2) {
21457 {
21458 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21459 temp3 = true;
21460 }
21461 }
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21465
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 {
21470 resultobj = SWIG_From_int((int)(result));
21471 }
21472 {
21473 if (temp3) delete arg3;
21474 }
21475 return resultobj;
21476 fail:
21477 {
21478 if (temp3) delete arg3;
21479 }
21480 return NULL;
21481 }
21482
21483
21484 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21485 PyObject *resultobj;
21486 wxDateTime *arg1 = (wxDateTime *) 0 ;
21487 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21488 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21489 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21490 int result;
21491 bool temp3 = false ;
21492 PyObject * obj0 = 0 ;
21493 PyObject * obj1 = 0 ;
21494 PyObject * obj2 = 0 ;
21495 char *kwnames[] = {
21496 (char *) "self",(char *) "flags",(char *) "tz", NULL
21497 };
21498
21499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21501 if (SWIG_arg_fail(1)) SWIG_fail;
21502 if (obj1) {
21503 {
21504 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21505 if (SWIG_arg_fail(2)) SWIG_fail;
21506 }
21507 }
21508 if (obj2) {
21509 {
21510 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21511 temp3 = true;
21512 }
21513 }
21514 {
21515 PyThreadState* __tstate = wxPyBeginAllowThreads();
21516 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21517
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 {
21522 resultobj = SWIG_From_int((int)(result));
21523 }
21524 {
21525 if (temp3) delete arg3;
21526 }
21527 return resultobj;
21528 fail:
21529 {
21530 if (temp3) delete arg3;
21531 }
21532 return NULL;
21533 }
21534
21535
21536 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21537 PyObject *resultobj;
21538 wxDateTime *arg1 = (wxDateTime *) 0 ;
21539 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21540 bool result;
21541 PyObject * obj0 = 0 ;
21542 PyObject * obj1 = 0 ;
21543 char *kwnames[] = {
21544 (char *) "self",(char *) "country", NULL
21545 };
21546
21547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21549 if (SWIG_arg_fail(1)) SWIG_fail;
21550 if (obj1) {
21551 {
21552 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21553 if (SWIG_arg_fail(2)) SWIG_fail;
21554 }
21555 }
21556 {
21557 PyThreadState* __tstate = wxPyBeginAllowThreads();
21558 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21559
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 {
21564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21565 }
21566 return resultobj;
21567 fail:
21568 return NULL;
21569 }
21570
21571
21572 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21573 PyObject *resultobj;
21574 wxDateTime *arg1 = (wxDateTime *) 0 ;
21575 wxDateTime *arg2 = 0 ;
21576 bool result;
21577 PyObject * obj0 = 0 ;
21578 PyObject * obj1 = 0 ;
21579 char *kwnames[] = {
21580 (char *) "self",(char *) "datetime", NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21585 if (SWIG_arg_fail(1)) SWIG_fail;
21586 {
21587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21588 if (SWIG_arg_fail(2)) SWIG_fail;
21589 if (arg2 == NULL) {
21590 SWIG_null_ref("wxDateTime");
21591 }
21592 if (SWIG_arg_fail(2)) SWIG_fail;
21593 }
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 {
21602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21603 }
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxDateTime *arg1 = (wxDateTime *) 0 ;
21613 wxDateTime *arg2 = 0 ;
21614 bool result;
21615 PyObject * obj0 = 0 ;
21616 PyObject * obj1 = 0 ;
21617 char *kwnames[] = {
21618 (char *) "self",(char *) "datetime", NULL
21619 };
21620
21621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21623 if (SWIG_arg_fail(1)) SWIG_fail;
21624 {
21625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21626 if (SWIG_arg_fail(2)) SWIG_fail;
21627 if (arg2 == NULL) {
21628 SWIG_null_ref("wxDateTime");
21629 }
21630 if (SWIG_arg_fail(2)) SWIG_fail;
21631 }
21632 {
21633 PyThreadState* __tstate = wxPyBeginAllowThreads();
21634 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21635
21636 wxPyEndAllowThreads(__tstate);
21637 if (PyErr_Occurred()) SWIG_fail;
21638 }
21639 {
21640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21641 }
21642 return resultobj;
21643 fail:
21644 return NULL;
21645 }
21646
21647
21648 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21649 PyObject *resultobj;
21650 wxDateTime *arg1 = (wxDateTime *) 0 ;
21651 wxDateTime *arg2 = 0 ;
21652 bool result;
21653 PyObject * obj0 = 0 ;
21654 PyObject * obj1 = 0 ;
21655 char *kwnames[] = {
21656 (char *) "self",(char *) "datetime", NULL
21657 };
21658
21659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21661 if (SWIG_arg_fail(1)) SWIG_fail;
21662 {
21663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21664 if (SWIG_arg_fail(2)) SWIG_fail;
21665 if (arg2 == NULL) {
21666 SWIG_null_ref("wxDateTime");
21667 }
21668 if (SWIG_arg_fail(2)) SWIG_fail;
21669 }
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21673
21674 wxPyEndAllowThreads(__tstate);
21675 if (PyErr_Occurred()) SWIG_fail;
21676 }
21677 {
21678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21679 }
21680 return resultobj;
21681 fail:
21682 return NULL;
21683 }
21684
21685
21686 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21687 PyObject *resultobj;
21688 wxDateTime *arg1 = (wxDateTime *) 0 ;
21689 wxDateTime *arg2 = 0 ;
21690 wxDateTime *arg3 = 0 ;
21691 bool result;
21692 PyObject * obj0 = 0 ;
21693 PyObject * obj1 = 0 ;
21694 PyObject * obj2 = 0 ;
21695 char *kwnames[] = {
21696 (char *) "self",(char *) "t1",(char *) "t2", NULL
21697 };
21698
21699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21701 if (SWIG_arg_fail(1)) SWIG_fail;
21702 {
21703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21704 if (SWIG_arg_fail(2)) SWIG_fail;
21705 if (arg2 == NULL) {
21706 SWIG_null_ref("wxDateTime");
21707 }
21708 if (SWIG_arg_fail(2)) SWIG_fail;
21709 }
21710 {
21711 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21712 if (SWIG_arg_fail(3)) SWIG_fail;
21713 if (arg3 == NULL) {
21714 SWIG_null_ref("wxDateTime");
21715 }
21716 if (SWIG_arg_fail(3)) SWIG_fail;
21717 }
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj;
21736 wxDateTime *arg1 = (wxDateTime *) 0 ;
21737 wxDateTime *arg2 = 0 ;
21738 wxDateTime *arg3 = 0 ;
21739 bool result;
21740 PyObject * obj0 = 0 ;
21741 PyObject * obj1 = 0 ;
21742 PyObject * obj2 = 0 ;
21743 char *kwnames[] = {
21744 (char *) "self",(char *) "t1",(char *) "t2", NULL
21745 };
21746
21747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21749 if (SWIG_arg_fail(1)) SWIG_fail;
21750 {
21751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21752 if (SWIG_arg_fail(2)) SWIG_fail;
21753 if (arg2 == NULL) {
21754 SWIG_null_ref("wxDateTime");
21755 }
21756 if (SWIG_arg_fail(2)) SWIG_fail;
21757 }
21758 {
21759 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21760 if (SWIG_arg_fail(3)) SWIG_fail;
21761 if (arg3 == NULL) {
21762 SWIG_null_ref("wxDateTime");
21763 }
21764 if (SWIG_arg_fail(3)) SWIG_fail;
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21769
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 {
21774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21775 }
21776 return resultobj;
21777 fail:
21778 return NULL;
21779 }
21780
21781
21782 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21783 PyObject *resultobj;
21784 wxDateTime *arg1 = (wxDateTime *) 0 ;
21785 wxDateTime *arg2 = 0 ;
21786 bool result;
21787 PyObject * obj0 = 0 ;
21788 PyObject * obj1 = 0 ;
21789 char *kwnames[] = {
21790 (char *) "self",(char *) "dt", NULL
21791 };
21792
21793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21795 if (SWIG_arg_fail(1)) SWIG_fail;
21796 {
21797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21798 if (SWIG_arg_fail(2)) SWIG_fail;
21799 if (arg2 == NULL) {
21800 SWIG_null_ref("wxDateTime");
21801 }
21802 if (SWIG_arg_fail(2)) SWIG_fail;
21803 }
21804 {
21805 PyThreadState* __tstate = wxPyBeginAllowThreads();
21806 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21807
21808 wxPyEndAllowThreads(__tstate);
21809 if (PyErr_Occurred()) SWIG_fail;
21810 }
21811 {
21812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21813 }
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21821 PyObject *resultobj;
21822 wxDateTime *arg1 = (wxDateTime *) 0 ;
21823 wxDateTime *arg2 = 0 ;
21824 bool result;
21825 PyObject * obj0 = 0 ;
21826 PyObject * obj1 = 0 ;
21827 char *kwnames[] = {
21828 (char *) "self",(char *) "dt", NULL
21829 };
21830
21831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21833 if (SWIG_arg_fail(1)) SWIG_fail;
21834 {
21835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21836 if (SWIG_arg_fail(2)) SWIG_fail;
21837 if (arg2 == NULL) {
21838 SWIG_null_ref("wxDateTime");
21839 }
21840 if (SWIG_arg_fail(2)) SWIG_fail;
21841 }
21842 {
21843 PyThreadState* __tstate = wxPyBeginAllowThreads();
21844 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21845
21846 wxPyEndAllowThreads(__tstate);
21847 if (PyErr_Occurred()) SWIG_fail;
21848 }
21849 {
21850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21851 }
21852 return resultobj;
21853 fail:
21854 return NULL;
21855 }
21856
21857
21858 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21859 PyObject *resultobj;
21860 wxDateTime *arg1 = (wxDateTime *) 0 ;
21861 wxDateTime *arg2 = 0 ;
21862 wxTimeSpan *arg3 = 0 ;
21863 bool result;
21864 PyObject * obj0 = 0 ;
21865 PyObject * obj1 = 0 ;
21866 PyObject * obj2 = 0 ;
21867 char *kwnames[] = {
21868 (char *) "self",(char *) "dt",(char *) "ts", NULL
21869 };
21870
21871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21873 if (SWIG_arg_fail(1)) SWIG_fail;
21874 {
21875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21876 if (SWIG_arg_fail(2)) SWIG_fail;
21877 if (arg2 == NULL) {
21878 SWIG_null_ref("wxDateTime");
21879 }
21880 if (SWIG_arg_fail(2)) SWIG_fail;
21881 }
21882 {
21883 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21884 if (SWIG_arg_fail(3)) SWIG_fail;
21885 if (arg3 == NULL) {
21886 SWIG_null_ref("wxTimeSpan");
21887 }
21888 if (SWIG_arg_fail(3)) SWIG_fail;
21889 }
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21893
21894 wxPyEndAllowThreads(__tstate);
21895 if (PyErr_Occurred()) SWIG_fail;
21896 }
21897 {
21898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21899 }
21900 return resultobj;
21901 fail:
21902 return NULL;
21903 }
21904
21905
21906 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21907 PyObject *resultobj;
21908 wxDateTime *arg1 = (wxDateTime *) 0 ;
21909 wxTimeSpan *arg2 = 0 ;
21910 wxDateTime *result;
21911 PyObject * obj0 = 0 ;
21912 PyObject * obj1 = 0 ;
21913 char *kwnames[] = {
21914 (char *) "self",(char *) "diff", NULL
21915 };
21916
21917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21919 if (SWIG_arg_fail(1)) SWIG_fail;
21920 {
21921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21922 if (SWIG_arg_fail(2)) SWIG_fail;
21923 if (arg2 == NULL) {
21924 SWIG_null_ref("wxTimeSpan");
21925 }
21926 if (SWIG_arg_fail(2)) SWIG_fail;
21927 }
21928 {
21929 PyThreadState* __tstate = wxPyBeginAllowThreads();
21930 {
21931 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21932 result = (wxDateTime *) &_result_ref;
21933 }
21934
21935 wxPyEndAllowThreads(__tstate);
21936 if (PyErr_Occurred()) SWIG_fail;
21937 }
21938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21946 PyObject *resultobj;
21947 wxDateTime *arg1 = (wxDateTime *) 0 ;
21948 wxDateSpan *arg2 = 0 ;
21949 wxDateTime *result;
21950 PyObject * obj0 = 0 ;
21951 PyObject * obj1 = 0 ;
21952 char *kwnames[] = {
21953 (char *) "self",(char *) "diff", NULL
21954 };
21955
21956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21958 if (SWIG_arg_fail(1)) SWIG_fail;
21959 {
21960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21961 if (SWIG_arg_fail(2)) SWIG_fail;
21962 if (arg2 == NULL) {
21963 SWIG_null_ref("wxDateSpan");
21964 }
21965 if (SWIG_arg_fail(2)) SWIG_fail;
21966 }
21967 {
21968 PyThreadState* __tstate = wxPyBeginAllowThreads();
21969 {
21970 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21971 result = (wxDateTime *) &_result_ref;
21972 }
21973
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
21985 PyObject *resultobj;
21986 wxDateTime *arg1 = (wxDateTime *) 0 ;
21987 wxTimeSpan *arg2 = 0 ;
21988 wxDateTime *result;
21989 PyObject * obj0 = 0 ;
21990 PyObject * obj1 = 0 ;
21991 char *kwnames[] = {
21992 (char *) "self",(char *) "diff", NULL
21993 };
21994
21995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
21996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21997 if (SWIG_arg_fail(1)) SWIG_fail;
21998 {
21999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22000 if (SWIG_arg_fail(2)) SWIG_fail;
22001 if (arg2 == NULL) {
22002 SWIG_null_ref("wxTimeSpan");
22003 }
22004 if (SWIG_arg_fail(2)) SWIG_fail;
22005 }
22006 {
22007 PyThreadState* __tstate = wxPyBeginAllowThreads();
22008 {
22009 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22010 result = (wxDateTime *) &_result_ref;
22011 }
22012
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22017 return resultobj;
22018 fail:
22019 return NULL;
22020 }
22021
22022
22023 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22024 PyObject *resultobj;
22025 wxDateTime *arg1 = (wxDateTime *) 0 ;
22026 wxDateSpan *arg2 = 0 ;
22027 wxDateTime *result;
22028 PyObject * obj0 = 0 ;
22029 PyObject * obj1 = 0 ;
22030 char *kwnames[] = {
22031 (char *) "self",(char *) "diff", NULL
22032 };
22033
22034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22036 if (SWIG_arg_fail(1)) SWIG_fail;
22037 {
22038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22039 if (SWIG_arg_fail(2)) SWIG_fail;
22040 if (arg2 == NULL) {
22041 SWIG_null_ref("wxDateSpan");
22042 }
22043 if (SWIG_arg_fail(2)) SWIG_fail;
22044 }
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 {
22048 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22049 result = (wxDateTime *) &_result_ref;
22050 }
22051
22052 wxPyEndAllowThreads(__tstate);
22053 if (PyErr_Occurred()) SWIG_fail;
22054 }
22055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22063 PyObject *resultobj;
22064 wxDateTime *arg1 = (wxDateTime *) 0 ;
22065 wxDateTime *arg2 = 0 ;
22066 wxTimeSpan result;
22067 PyObject * obj0 = 0 ;
22068 PyObject * obj1 = 0 ;
22069 char *kwnames[] = {
22070 (char *) "self",(char *) "dt", NULL
22071 };
22072
22073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(1)) SWIG_fail;
22076 {
22077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(2)) SWIG_fail;
22079 if (arg2 == NULL) {
22080 SWIG_null_ref("wxDateTime");
22081 }
22082 if (SWIG_arg_fail(2)) SWIG_fail;
22083 }
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22087
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 {
22092 wxTimeSpan * resultptr;
22093 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22095 }
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22103 PyObject *resultobj;
22104 wxDateTime *arg1 = (wxDateTime *) 0 ;
22105 wxTimeSpan *arg2 = 0 ;
22106 wxDateTime *result;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109
22110 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22115 if (SWIG_arg_fail(2)) SWIG_fail;
22116 if (arg2 == NULL) {
22117 SWIG_null_ref("wxTimeSpan");
22118 }
22119 if (SWIG_arg_fail(2)) SWIG_fail;
22120 }
22121 {
22122 PyThreadState* __tstate = wxPyBeginAllowThreads();
22123 {
22124 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22125 result = (wxDateTime *) &_result_ref;
22126 }
22127
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22139 PyObject *resultobj;
22140 wxDateTime *arg1 = (wxDateTime *) 0 ;
22141 wxDateSpan *arg2 = 0 ;
22142 wxDateTime *result;
22143 PyObject * obj0 = 0 ;
22144 PyObject * obj1 = 0 ;
22145
22146 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22148 if (SWIG_arg_fail(1)) SWIG_fail;
22149 {
22150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22151 if (SWIG_arg_fail(2)) SWIG_fail;
22152 if (arg2 == NULL) {
22153 SWIG_null_ref("wxDateSpan");
22154 }
22155 if (SWIG_arg_fail(2)) SWIG_fail;
22156 }
22157 {
22158 PyThreadState* __tstate = wxPyBeginAllowThreads();
22159 {
22160 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22161 result = (wxDateTime *) &_result_ref;
22162 }
22163
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22168 return resultobj;
22169 fail:
22170 return NULL;
22171 }
22172
22173
22174 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22175 int argc;
22176 PyObject *argv[3];
22177 int ii;
22178
22179 argc = PyObject_Length(args);
22180 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22181 argv[ii] = PyTuple_GetItem(args,ii);
22182 }
22183 if (argc == 2) {
22184 int _v;
22185 {
22186 void *ptr;
22187 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22188 _v = 0;
22189 PyErr_Clear();
22190 } else {
22191 _v = 1;
22192 }
22193 }
22194 if (_v) {
22195 {
22196 void *ptr = 0;
22197 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22198 _v = 0;
22199 PyErr_Clear();
22200 } else {
22201 _v = (ptr != 0);
22202 }
22203 }
22204 if (_v) {
22205 return _wrap_DateTime___iadd____SWIG_0(self,args);
22206 }
22207 }
22208 }
22209 if (argc == 2) {
22210 int _v;
22211 {
22212 void *ptr;
22213 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22214 _v = 0;
22215 PyErr_Clear();
22216 } else {
22217 _v = 1;
22218 }
22219 }
22220 if (_v) {
22221 {
22222 void *ptr = 0;
22223 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22224 _v = 0;
22225 PyErr_Clear();
22226 } else {
22227 _v = (ptr != 0);
22228 }
22229 }
22230 if (_v) {
22231 return _wrap_DateTime___iadd____SWIG_1(self,args);
22232 }
22233 }
22234 }
22235
22236 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22237 return NULL;
22238 }
22239
22240
22241 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22242 PyObject *resultobj;
22243 wxDateTime *arg1 = (wxDateTime *) 0 ;
22244 wxTimeSpan *arg2 = 0 ;
22245 wxDateTime *result;
22246 PyObject * obj0 = 0 ;
22247 PyObject * obj1 = 0 ;
22248
22249 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22251 if (SWIG_arg_fail(1)) SWIG_fail;
22252 {
22253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22254 if (SWIG_arg_fail(2)) SWIG_fail;
22255 if (arg2 == NULL) {
22256 SWIG_null_ref("wxTimeSpan");
22257 }
22258 if (SWIG_arg_fail(2)) SWIG_fail;
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 {
22263 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22264 result = (wxDateTime *) &_result_ref;
22265 }
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22278 PyObject *resultobj;
22279 wxDateTime *arg1 = (wxDateTime *) 0 ;
22280 wxDateSpan *arg2 = 0 ;
22281 wxDateTime *result;
22282 PyObject * obj0 = 0 ;
22283 PyObject * obj1 = 0 ;
22284
22285 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22287 if (SWIG_arg_fail(1)) SWIG_fail;
22288 {
22289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22290 if (SWIG_arg_fail(2)) SWIG_fail;
22291 if (arg2 == NULL) {
22292 SWIG_null_ref("wxDateSpan");
22293 }
22294 if (SWIG_arg_fail(2)) SWIG_fail;
22295 }
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 {
22299 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22300 result = (wxDateTime *) &_result_ref;
22301 }
22302
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22314 int argc;
22315 PyObject *argv[3];
22316 int ii;
22317
22318 argc = PyObject_Length(args);
22319 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22320 argv[ii] = PyTuple_GetItem(args,ii);
22321 }
22322 if (argc == 2) {
22323 int _v;
22324 {
22325 void *ptr;
22326 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22327 _v = 0;
22328 PyErr_Clear();
22329 } else {
22330 _v = 1;
22331 }
22332 }
22333 if (_v) {
22334 {
22335 void *ptr = 0;
22336 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22337 _v = 0;
22338 PyErr_Clear();
22339 } else {
22340 _v = (ptr != 0);
22341 }
22342 }
22343 if (_v) {
22344 return _wrap_DateTime___isub____SWIG_0(self,args);
22345 }
22346 }
22347 }
22348 if (argc == 2) {
22349 int _v;
22350 {
22351 void *ptr;
22352 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22353 _v = 0;
22354 PyErr_Clear();
22355 } else {
22356 _v = 1;
22357 }
22358 }
22359 if (_v) {
22360 {
22361 void *ptr = 0;
22362 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22363 _v = 0;
22364 PyErr_Clear();
22365 } else {
22366 _v = (ptr != 0);
22367 }
22368 }
22369 if (_v) {
22370 return _wrap_DateTime___isub____SWIG_1(self,args);
22371 }
22372 }
22373 }
22374
22375 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22376 return NULL;
22377 }
22378
22379
22380 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22381 PyObject *resultobj;
22382 wxDateTime *arg1 = (wxDateTime *) 0 ;
22383 wxTimeSpan *arg2 = 0 ;
22384 wxDateTime result;
22385 PyObject * obj0 = 0 ;
22386 PyObject * obj1 = 0 ;
22387
22388 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22390 if (SWIG_arg_fail(1)) SWIG_fail;
22391 {
22392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22393 if (SWIG_arg_fail(2)) SWIG_fail;
22394 if (arg2 == NULL) {
22395 SWIG_null_ref("wxTimeSpan");
22396 }
22397 if (SWIG_arg_fail(2)) SWIG_fail;
22398 }
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22402
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 {
22407 wxDateTime * resultptr;
22408 resultptr = new wxDateTime((wxDateTime &)(result));
22409 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22410 }
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22418 PyObject *resultobj;
22419 wxDateTime *arg1 = (wxDateTime *) 0 ;
22420 wxDateSpan *arg2 = 0 ;
22421 wxDateTime result;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424
22425 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22427 if (SWIG_arg_fail(1)) SWIG_fail;
22428 {
22429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22430 if (SWIG_arg_fail(2)) SWIG_fail;
22431 if (arg2 == NULL) {
22432 SWIG_null_ref("wxDateSpan");
22433 }
22434 if (SWIG_arg_fail(2)) SWIG_fail;
22435 }
22436 {
22437 PyThreadState* __tstate = wxPyBeginAllowThreads();
22438 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22439
22440 wxPyEndAllowThreads(__tstate);
22441 if (PyErr_Occurred()) SWIG_fail;
22442 }
22443 {
22444 wxDateTime * resultptr;
22445 resultptr = new wxDateTime((wxDateTime &)(result));
22446 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22447 }
22448 return resultobj;
22449 fail:
22450 return NULL;
22451 }
22452
22453
22454 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22455 int argc;
22456 PyObject *argv[3];
22457 int ii;
22458
22459 argc = PyObject_Length(args);
22460 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22461 argv[ii] = PyTuple_GetItem(args,ii);
22462 }
22463 if (argc == 2) {
22464 int _v;
22465 {
22466 void *ptr;
22467 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22468 _v = 0;
22469 PyErr_Clear();
22470 } else {
22471 _v = 1;
22472 }
22473 }
22474 if (_v) {
22475 {
22476 void *ptr = 0;
22477 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22478 _v = 0;
22479 PyErr_Clear();
22480 } else {
22481 _v = (ptr != 0);
22482 }
22483 }
22484 if (_v) {
22485 return _wrap_DateTime___add____SWIG_0(self,args);
22486 }
22487 }
22488 }
22489 if (argc == 2) {
22490 int _v;
22491 {
22492 void *ptr;
22493 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22494 _v = 0;
22495 PyErr_Clear();
22496 } else {
22497 _v = 1;
22498 }
22499 }
22500 if (_v) {
22501 {
22502 void *ptr = 0;
22503 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22504 _v = 0;
22505 PyErr_Clear();
22506 } else {
22507 _v = (ptr != 0);
22508 }
22509 }
22510 if (_v) {
22511 return _wrap_DateTime___add____SWIG_1(self,args);
22512 }
22513 }
22514 }
22515
22516 Py_INCREF(Py_NotImplemented);
22517 return Py_NotImplemented;
22518 }
22519
22520
22521 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22522 PyObject *resultobj;
22523 wxDateTime *arg1 = (wxDateTime *) 0 ;
22524 wxDateTime *arg2 = 0 ;
22525 wxTimeSpan result;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528
22529 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22531 if (SWIG_arg_fail(1)) SWIG_fail;
22532 {
22533 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22534 if (SWIG_arg_fail(2)) SWIG_fail;
22535 if (arg2 == NULL) {
22536 SWIG_null_ref("wxDateTime");
22537 }
22538 if (SWIG_arg_fail(2)) SWIG_fail;
22539 }
22540 {
22541 PyThreadState* __tstate = wxPyBeginAllowThreads();
22542 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22543
22544 wxPyEndAllowThreads(__tstate);
22545 if (PyErr_Occurred()) SWIG_fail;
22546 }
22547 {
22548 wxTimeSpan * resultptr;
22549 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22551 }
22552 return resultobj;
22553 fail:
22554 return NULL;
22555 }
22556
22557
22558 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22559 PyObject *resultobj;
22560 wxDateTime *arg1 = (wxDateTime *) 0 ;
22561 wxTimeSpan *arg2 = 0 ;
22562 wxDateTime result;
22563 PyObject * obj0 = 0 ;
22564 PyObject * obj1 = 0 ;
22565
22566 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22568 if (SWIG_arg_fail(1)) SWIG_fail;
22569 {
22570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22571 if (SWIG_arg_fail(2)) SWIG_fail;
22572 if (arg2 == NULL) {
22573 SWIG_null_ref("wxTimeSpan");
22574 }
22575 if (SWIG_arg_fail(2)) SWIG_fail;
22576 }
22577 {
22578 PyThreadState* __tstate = wxPyBeginAllowThreads();
22579 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22580
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 {
22585 wxDateTime * resultptr;
22586 resultptr = new wxDateTime((wxDateTime &)(result));
22587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22588 }
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22596 PyObject *resultobj;
22597 wxDateTime *arg1 = (wxDateTime *) 0 ;
22598 wxDateSpan *arg2 = 0 ;
22599 wxDateTime result;
22600 PyObject * obj0 = 0 ;
22601 PyObject * obj1 = 0 ;
22602
22603 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(1)) SWIG_fail;
22606 {
22607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22608 if (SWIG_arg_fail(2)) SWIG_fail;
22609 if (arg2 == NULL) {
22610 SWIG_null_ref("wxDateSpan");
22611 }
22612 if (SWIG_arg_fail(2)) SWIG_fail;
22613 }
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22617
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 {
22622 wxDateTime * resultptr;
22623 resultptr = new wxDateTime((wxDateTime &)(result));
22624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22625 }
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22633 int argc;
22634 PyObject *argv[3];
22635 int ii;
22636
22637 argc = PyObject_Length(args);
22638 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22639 argv[ii] = PyTuple_GetItem(args,ii);
22640 }
22641 if (argc == 2) {
22642 int _v;
22643 {
22644 void *ptr;
22645 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22646 _v = 0;
22647 PyErr_Clear();
22648 } else {
22649 _v = 1;
22650 }
22651 }
22652 if (_v) {
22653 {
22654 void *ptr = 0;
22655 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22656 _v = 0;
22657 PyErr_Clear();
22658 } else {
22659 _v = (ptr != 0);
22660 }
22661 }
22662 if (_v) {
22663 return _wrap_DateTime___sub____SWIG_0(self,args);
22664 }
22665 }
22666 }
22667 if (argc == 2) {
22668 int _v;
22669 {
22670 void *ptr;
22671 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22672 _v = 0;
22673 PyErr_Clear();
22674 } else {
22675 _v = 1;
22676 }
22677 }
22678 if (_v) {
22679 {
22680 void *ptr = 0;
22681 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22682 _v = 0;
22683 PyErr_Clear();
22684 } else {
22685 _v = (ptr != 0);
22686 }
22687 }
22688 if (_v) {
22689 return _wrap_DateTime___sub____SWIG_1(self,args);
22690 }
22691 }
22692 }
22693 if (argc == 2) {
22694 int _v;
22695 {
22696 void *ptr;
22697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22698 _v = 0;
22699 PyErr_Clear();
22700 } else {
22701 _v = 1;
22702 }
22703 }
22704 if (_v) {
22705 {
22706 void *ptr = 0;
22707 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22708 _v = 0;
22709 PyErr_Clear();
22710 } else {
22711 _v = (ptr != 0);
22712 }
22713 }
22714 if (_v) {
22715 return _wrap_DateTime___sub____SWIG_2(self,args);
22716 }
22717 }
22718 }
22719
22720 Py_INCREF(Py_NotImplemented);
22721 return Py_NotImplemented;
22722 }
22723
22724
22725 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args) {
22726 PyObject *resultobj;
22727 wxDateTime *arg1 = (wxDateTime *) 0 ;
22728 wxDateTime *arg2 = (wxDateTime *) 0 ;
22729 bool result;
22730 PyObject * obj0 = 0 ;
22731 PyObject * obj1 = 0 ;
22732
22733 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___lt__",&obj0,&obj1)) goto fail;
22734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(1)) SWIG_fail;
22736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22737 if (SWIG_arg_fail(2)) SWIG_fail;
22738 {
22739 PyThreadState* __tstate = wxPyBeginAllowThreads();
22740 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22741
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 {
22746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22747 }
22748 return resultobj;
22749 fail:
22750 return NULL;
22751 }
22752
22753
22754 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args) {
22755 PyObject *resultobj;
22756 wxDateTime *arg1 = (wxDateTime *) 0 ;
22757 wxDateTime *arg2 = (wxDateTime *) 0 ;
22758 bool result;
22759 PyObject * obj0 = 0 ;
22760 PyObject * obj1 = 0 ;
22761
22762 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___le__",&obj0,&obj1)) goto fail;
22763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22764 if (SWIG_arg_fail(1)) SWIG_fail;
22765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22766 if (SWIG_arg_fail(2)) SWIG_fail;
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22770
22771 wxPyEndAllowThreads(__tstate);
22772 if (PyErr_Occurred()) SWIG_fail;
22773 }
22774 {
22775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22776 }
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args) {
22784 PyObject *resultobj;
22785 wxDateTime *arg1 = (wxDateTime *) 0 ;
22786 wxDateTime *arg2 = (wxDateTime *) 0 ;
22787 bool result;
22788 PyObject * obj0 = 0 ;
22789 PyObject * obj1 = 0 ;
22790
22791 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___gt__",&obj0,&obj1)) goto fail;
22792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22793 if (SWIG_arg_fail(1)) SWIG_fail;
22794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22795 if (SWIG_arg_fail(2)) SWIG_fail;
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22799
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 {
22804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args) {
22813 PyObject *resultobj;
22814 wxDateTime *arg1 = (wxDateTime *) 0 ;
22815 wxDateTime *arg2 = (wxDateTime *) 0 ;
22816 bool result;
22817 PyObject * obj0 = 0 ;
22818 PyObject * obj1 = 0 ;
22819
22820 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ge__",&obj0,&obj1)) goto fail;
22821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22822 if (SWIG_arg_fail(1)) SWIG_fail;
22823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22824 if (SWIG_arg_fail(2)) SWIG_fail;
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22828
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args) {
22842 PyObject *resultobj;
22843 wxDateTime *arg1 = (wxDateTime *) 0 ;
22844 wxDateTime *arg2 = (wxDateTime *) 0 ;
22845 bool result;
22846 PyObject * obj0 = 0 ;
22847 PyObject * obj1 = 0 ;
22848
22849 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___eq__",&obj0,&obj1)) goto fail;
22850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22851 if (SWIG_arg_fail(1)) SWIG_fail;
22852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22853 if (SWIG_arg_fail(2)) SWIG_fail;
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22857
22858 wxPyEndAllowThreads(__tstate);
22859 if (PyErr_Occurred()) SWIG_fail;
22860 }
22861 {
22862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22863 }
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args) {
22871 PyObject *resultobj;
22872 wxDateTime *arg1 = (wxDateTime *) 0 ;
22873 wxDateTime *arg2 = (wxDateTime *) 0 ;
22874 bool result;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877
22878 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___ne__",&obj0,&obj1)) goto fail;
22879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(1)) SWIG_fail;
22881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22882 if (SWIG_arg_fail(2)) SWIG_fail;
22883 {
22884 PyThreadState* __tstate = wxPyBeginAllowThreads();
22885 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22886
22887 wxPyEndAllowThreads(__tstate);
22888 if (PyErr_Occurred()) SWIG_fail;
22889 }
22890 {
22891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22892 }
22893 return resultobj;
22894 fail:
22895 return NULL;
22896 }
22897
22898
22899 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22900 PyObject *resultobj;
22901 wxDateTime *arg1 = (wxDateTime *) 0 ;
22902 wxString *arg2 = 0 ;
22903 int result;
22904 bool temp2 = false ;
22905 PyObject * obj0 = 0 ;
22906 PyObject * obj1 = 0 ;
22907 char *kwnames[] = {
22908 (char *) "self",(char *) "date", NULL
22909 };
22910
22911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22913 if (SWIG_arg_fail(1)) SWIG_fail;
22914 {
22915 arg2 = wxString_in_helper(obj1);
22916 if (arg2 == NULL) SWIG_fail;
22917 temp2 = true;
22918 }
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22922
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 {
22927 resultobj = SWIG_From_int((int)(result));
22928 }
22929 {
22930 if (temp2)
22931 delete arg2;
22932 }
22933 return resultobj;
22934 fail:
22935 {
22936 if (temp2)
22937 delete arg2;
22938 }
22939 return NULL;
22940 }
22941
22942
22943 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22944 PyObject *resultobj;
22945 wxDateTime *arg1 = (wxDateTime *) 0 ;
22946 wxString *arg2 = 0 ;
22947 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22948 wxString *arg3 = (wxString *) &arg3_defvalue ;
22949 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22950 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22951 int result;
22952 bool temp2 = false ;
22953 bool temp3 = false ;
22954 PyObject * obj0 = 0 ;
22955 PyObject * obj1 = 0 ;
22956 PyObject * obj2 = 0 ;
22957 PyObject * obj3 = 0 ;
22958 char *kwnames[] = {
22959 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22960 };
22961
22962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22964 if (SWIG_arg_fail(1)) SWIG_fail;
22965 {
22966 arg2 = wxString_in_helper(obj1);
22967 if (arg2 == NULL) SWIG_fail;
22968 temp2 = true;
22969 }
22970 if (obj2) {
22971 {
22972 arg3 = wxString_in_helper(obj2);
22973 if (arg3 == NULL) SWIG_fail;
22974 temp3 = true;
22975 }
22976 }
22977 if (obj3) {
22978 {
22979 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22980 if (SWIG_arg_fail(4)) SWIG_fail;
22981 if (arg4 == NULL) {
22982 SWIG_null_ref("wxDateTime");
22983 }
22984 if (SWIG_arg_fail(4)) SWIG_fail;
22985 }
22986 }
22987 {
22988 PyThreadState* __tstate = wxPyBeginAllowThreads();
22989 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
22990
22991 wxPyEndAllowThreads(__tstate);
22992 if (PyErr_Occurred()) SWIG_fail;
22993 }
22994 {
22995 resultobj = SWIG_From_int((int)(result));
22996 }
22997 {
22998 if (temp2)
22999 delete arg2;
23000 }
23001 {
23002 if (temp3)
23003 delete arg3;
23004 }
23005 return resultobj;
23006 fail:
23007 {
23008 if (temp2)
23009 delete arg2;
23010 }
23011 {
23012 if (temp3)
23013 delete arg3;
23014 }
23015 return NULL;
23016 }
23017
23018
23019 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23020 PyObject *resultobj;
23021 wxDateTime *arg1 = (wxDateTime *) 0 ;
23022 wxString *arg2 = 0 ;
23023 int result;
23024 bool temp2 = false ;
23025 PyObject * obj0 = 0 ;
23026 PyObject * obj1 = 0 ;
23027 char *kwnames[] = {
23028 (char *) "self",(char *) "datetime", NULL
23029 };
23030
23031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23033 if (SWIG_arg_fail(1)) SWIG_fail;
23034 {
23035 arg2 = wxString_in_helper(obj1);
23036 if (arg2 == NULL) SWIG_fail;
23037 temp2 = true;
23038 }
23039 {
23040 PyThreadState* __tstate = wxPyBeginAllowThreads();
23041 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23042
23043 wxPyEndAllowThreads(__tstate);
23044 if (PyErr_Occurred()) SWIG_fail;
23045 }
23046 {
23047 resultobj = SWIG_From_int((int)(result));
23048 }
23049 {
23050 if (temp2)
23051 delete arg2;
23052 }
23053 return resultobj;
23054 fail:
23055 {
23056 if (temp2)
23057 delete arg2;
23058 }
23059 return NULL;
23060 }
23061
23062
23063 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23064 PyObject *resultobj;
23065 wxDateTime *arg1 = (wxDateTime *) 0 ;
23066 wxString *arg2 = 0 ;
23067 int result;
23068 bool temp2 = false ;
23069 PyObject * obj0 = 0 ;
23070 PyObject * obj1 = 0 ;
23071 char *kwnames[] = {
23072 (char *) "self",(char *) "date", NULL
23073 };
23074
23075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23077 if (SWIG_arg_fail(1)) SWIG_fail;
23078 {
23079 arg2 = wxString_in_helper(obj1);
23080 if (arg2 == NULL) SWIG_fail;
23081 temp2 = true;
23082 }
23083 {
23084 PyThreadState* __tstate = wxPyBeginAllowThreads();
23085 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23086
23087 wxPyEndAllowThreads(__tstate);
23088 if (PyErr_Occurred()) SWIG_fail;
23089 }
23090 {
23091 resultobj = SWIG_From_int((int)(result));
23092 }
23093 {
23094 if (temp2)
23095 delete arg2;
23096 }
23097 return resultobj;
23098 fail:
23099 {
23100 if (temp2)
23101 delete arg2;
23102 }
23103 return NULL;
23104 }
23105
23106
23107 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23108 PyObject *resultobj;
23109 wxDateTime *arg1 = (wxDateTime *) 0 ;
23110 wxString *arg2 = 0 ;
23111 int result;
23112 bool temp2 = false ;
23113 PyObject * obj0 = 0 ;
23114 PyObject * obj1 = 0 ;
23115 char *kwnames[] = {
23116 (char *) "self",(char *) "time", NULL
23117 };
23118
23119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(1)) SWIG_fail;
23122 {
23123 arg2 = wxString_in_helper(obj1);
23124 if (arg2 == NULL) SWIG_fail;
23125 temp2 = true;
23126 }
23127 {
23128 PyThreadState* __tstate = wxPyBeginAllowThreads();
23129 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23130
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 {
23135 resultobj = SWIG_From_int((int)(result));
23136 }
23137 {
23138 if (temp2)
23139 delete arg2;
23140 }
23141 return resultobj;
23142 fail:
23143 {
23144 if (temp2)
23145 delete arg2;
23146 }
23147 return NULL;
23148 }
23149
23150
23151 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23152 PyObject *resultobj;
23153 wxDateTime *arg1 = (wxDateTime *) 0 ;
23154 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23155 wxString *arg2 = (wxString *) &arg2_defvalue ;
23156 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23157 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23158 wxString result;
23159 bool temp2 = false ;
23160 bool temp3 = false ;
23161 PyObject * obj0 = 0 ;
23162 PyObject * obj1 = 0 ;
23163 PyObject * obj2 = 0 ;
23164 char *kwnames[] = {
23165 (char *) "self",(char *) "format",(char *) "tz", NULL
23166 };
23167
23168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23170 if (SWIG_arg_fail(1)) SWIG_fail;
23171 if (obj1) {
23172 {
23173 arg2 = wxString_in_helper(obj1);
23174 if (arg2 == NULL) SWIG_fail;
23175 temp2 = true;
23176 }
23177 }
23178 if (obj2) {
23179 {
23180 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23181 temp3 = true;
23182 }
23183 }
23184 {
23185 PyThreadState* __tstate = wxPyBeginAllowThreads();
23186 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23187
23188 wxPyEndAllowThreads(__tstate);
23189 if (PyErr_Occurred()) SWIG_fail;
23190 }
23191 {
23192 #if wxUSE_UNICODE
23193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23194 #else
23195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23196 #endif
23197 }
23198 {
23199 if (temp2)
23200 delete arg2;
23201 }
23202 {
23203 if (temp3) delete arg3;
23204 }
23205 return resultobj;
23206 fail:
23207 {
23208 if (temp2)
23209 delete arg2;
23210 }
23211 {
23212 if (temp3) delete arg3;
23213 }
23214 return NULL;
23215 }
23216
23217
23218 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23219 PyObject *resultobj;
23220 wxDateTime *arg1 = (wxDateTime *) 0 ;
23221 wxString result;
23222 PyObject * obj0 = 0 ;
23223 char *kwnames[] = {
23224 (char *) "self", NULL
23225 };
23226
23227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23229 if (SWIG_arg_fail(1)) SWIG_fail;
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = ((wxDateTime const *)arg1)->FormatDate();
23233
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 #if wxUSE_UNICODE
23239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23240 #else
23241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23242 #endif
23243 }
23244 return resultobj;
23245 fail:
23246 return NULL;
23247 }
23248
23249
23250 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23251 PyObject *resultobj;
23252 wxDateTime *arg1 = (wxDateTime *) 0 ;
23253 wxString result;
23254 PyObject * obj0 = 0 ;
23255 char *kwnames[] = {
23256 (char *) "self", NULL
23257 };
23258
23259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23261 if (SWIG_arg_fail(1)) SWIG_fail;
23262 {
23263 PyThreadState* __tstate = wxPyBeginAllowThreads();
23264 result = ((wxDateTime const *)arg1)->FormatTime();
23265
23266 wxPyEndAllowThreads(__tstate);
23267 if (PyErr_Occurred()) SWIG_fail;
23268 }
23269 {
23270 #if wxUSE_UNICODE
23271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23272 #else
23273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23274 #endif
23275 }
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23283 PyObject *resultobj;
23284 wxDateTime *arg1 = (wxDateTime *) 0 ;
23285 wxString result;
23286 PyObject * obj0 = 0 ;
23287 char *kwnames[] = {
23288 (char *) "self", NULL
23289 };
23290
23291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23293 if (SWIG_arg_fail(1)) SWIG_fail;
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 result = ((wxDateTime const *)arg1)->FormatISODate();
23297
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 {
23302 #if wxUSE_UNICODE
23303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23304 #else
23305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23306 #endif
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 wxDateTime *arg1 = (wxDateTime *) 0 ;
23317 wxString result;
23318 PyObject * obj0 = 0 ;
23319 char *kwnames[] = {
23320 (char *) "self", NULL
23321 };
23322
23323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23325 if (SWIG_arg_fail(1)) SWIG_fail;
23326 {
23327 PyThreadState* __tstate = wxPyBeginAllowThreads();
23328 result = ((wxDateTime const *)arg1)->FormatISOTime();
23329
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 {
23334 #if wxUSE_UNICODE
23335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23336 #else
23337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23338 #endif
23339 }
23340 return resultobj;
23341 fail:
23342 return NULL;
23343 }
23344
23345
23346 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23347 PyObject *obj;
23348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23349 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23350 Py_INCREF(obj);
23351 return Py_BuildValue((char *)"");
23352 }
23353 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23354 PyObject *resultobj;
23355 long arg1 ;
23356 wxTimeSpan result;
23357 PyObject * obj0 = 0 ;
23358 char *kwnames[] = {
23359 (char *) "sec", NULL
23360 };
23361
23362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23363 {
23364 arg1 = (long)(SWIG_As_long(obj0));
23365 if (SWIG_arg_fail(1)) SWIG_fail;
23366 }
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 result = wxTimeSpan::Seconds(arg1);
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 {
23375 wxTimeSpan * resultptr;
23376 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23377 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23378 }
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj;
23387 wxTimeSpan result;
23388 char *kwnames[] = {
23389 NULL
23390 };
23391
23392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = wxTimeSpan::Second();
23396
23397 wxPyEndAllowThreads(__tstate);
23398 if (PyErr_Occurred()) SWIG_fail;
23399 }
23400 {
23401 wxTimeSpan * resultptr;
23402 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23412 PyObject *resultobj;
23413 long arg1 ;
23414 wxTimeSpan result;
23415 PyObject * obj0 = 0 ;
23416 char *kwnames[] = {
23417 (char *) "min", NULL
23418 };
23419
23420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23421 {
23422 arg1 = (long)(SWIG_As_long(obj0));
23423 if (SWIG_arg_fail(1)) SWIG_fail;
23424 }
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 result = wxTimeSpan::Minutes(arg1);
23428
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 wxTimeSpan * resultptr;
23434 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23436 }
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23444 PyObject *resultobj;
23445 wxTimeSpan result;
23446 char *kwnames[] = {
23447 NULL
23448 };
23449
23450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23451 {
23452 PyThreadState* __tstate = wxPyBeginAllowThreads();
23453 result = wxTimeSpan::Minute();
23454
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 wxTimeSpan * resultptr;
23460 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23461 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23462 }
23463 return resultobj;
23464 fail:
23465 return NULL;
23466 }
23467
23468
23469 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23470 PyObject *resultobj;
23471 long arg1 ;
23472 wxTimeSpan result;
23473 PyObject * obj0 = 0 ;
23474 char *kwnames[] = {
23475 (char *) "hours", NULL
23476 };
23477
23478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23479 {
23480 arg1 = (long)(SWIG_As_long(obj0));
23481 if (SWIG_arg_fail(1)) SWIG_fail;
23482 }
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = wxTimeSpan::Hours(arg1);
23486
23487 wxPyEndAllowThreads(__tstate);
23488 if (PyErr_Occurred()) SWIG_fail;
23489 }
23490 {
23491 wxTimeSpan * resultptr;
23492 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj;
23503 wxTimeSpan result;
23504 char *kwnames[] = {
23505 NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = wxTimeSpan::Hour();
23512
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 {
23517 wxTimeSpan * resultptr;
23518 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23519 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23520 }
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj;
23529 long arg1 ;
23530 wxTimeSpan result;
23531 PyObject * obj0 = 0 ;
23532 char *kwnames[] = {
23533 (char *) "days", NULL
23534 };
23535
23536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23537 {
23538 arg1 = (long)(SWIG_As_long(obj0));
23539 if (SWIG_arg_fail(1)) SWIG_fail;
23540 }
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 result = wxTimeSpan::Days(arg1);
23544
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 {
23549 wxTimeSpan * resultptr;
23550 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj;
23561 wxTimeSpan result;
23562 char *kwnames[] = {
23563 NULL
23564 };
23565
23566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 result = wxTimeSpan::Day();
23570
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 {
23575 wxTimeSpan * resultptr;
23576 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23578 }
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj;
23587 long arg1 ;
23588 wxTimeSpan result;
23589 PyObject * obj0 = 0 ;
23590 char *kwnames[] = {
23591 (char *) "days", NULL
23592 };
23593
23594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23595 {
23596 arg1 = (long)(SWIG_As_long(obj0));
23597 if (SWIG_arg_fail(1)) SWIG_fail;
23598 }
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = wxTimeSpan::Weeks(arg1);
23602
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 {
23607 wxTimeSpan * resultptr;
23608 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxTimeSpan result;
23620 char *kwnames[] = {
23621 NULL
23622 };
23623
23624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = wxTimeSpan::Week();
23628
23629 wxPyEndAllowThreads(__tstate);
23630 if (PyErr_Occurred()) SWIG_fail;
23631 }
23632 {
23633 wxTimeSpan * resultptr;
23634 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23636 }
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23644 PyObject *resultobj;
23645 long arg1 = (long) 0 ;
23646 long arg2 = (long) 0 ;
23647 long arg3 = (long) 0 ;
23648 long arg4 = (long) 0 ;
23649 wxTimeSpan *result;
23650 PyObject * obj0 = 0 ;
23651 PyObject * obj1 = 0 ;
23652 PyObject * obj2 = 0 ;
23653 PyObject * obj3 = 0 ;
23654 char *kwnames[] = {
23655 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23659 if (obj0) {
23660 {
23661 arg1 = (long)(SWIG_As_long(obj0));
23662 if (SWIG_arg_fail(1)) SWIG_fail;
23663 }
23664 }
23665 if (obj1) {
23666 {
23667 arg2 = (long)(SWIG_As_long(obj1));
23668 if (SWIG_arg_fail(2)) SWIG_fail;
23669 }
23670 }
23671 if (obj2) {
23672 {
23673 arg3 = (long)(SWIG_As_long(obj2));
23674 if (SWIG_arg_fail(3)) SWIG_fail;
23675 }
23676 }
23677 if (obj3) {
23678 {
23679 arg4 = (long)(SWIG_As_long(obj3));
23680 if (SWIG_arg_fail(4)) SWIG_fail;
23681 }
23682 }
23683 {
23684 PyThreadState* __tstate = wxPyBeginAllowThreads();
23685 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23686
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj;
23699 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23700 PyObject * obj0 = 0 ;
23701 char *kwnames[] = {
23702 (char *) "self", NULL
23703 };
23704
23705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23707 if (SWIG_arg_fail(1)) SWIG_fail;
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 delete arg1;
23711
23712 wxPyEndAllowThreads(__tstate);
23713 if (PyErr_Occurred()) SWIG_fail;
23714 }
23715 Py_INCREF(Py_None); resultobj = Py_None;
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23725 wxTimeSpan *arg2 = 0 ;
23726 wxTimeSpan *result;
23727 PyObject * obj0 = 0 ;
23728 PyObject * obj1 = 0 ;
23729 char *kwnames[] = {
23730 (char *) "self",(char *) "diff", NULL
23731 };
23732
23733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23735 if (SWIG_arg_fail(1)) SWIG_fail;
23736 {
23737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23738 if (SWIG_arg_fail(2)) SWIG_fail;
23739 if (arg2 == NULL) {
23740 SWIG_null_ref("wxTimeSpan");
23741 }
23742 if (SWIG_arg_fail(2)) SWIG_fail;
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 {
23747 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23748 result = (wxTimeSpan *) &_result_ref;
23749 }
23750
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23762 PyObject *resultobj;
23763 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23764 wxTimeSpan *arg2 = 0 ;
23765 wxTimeSpan *result;
23766 PyObject * obj0 = 0 ;
23767 PyObject * obj1 = 0 ;
23768 char *kwnames[] = {
23769 (char *) "self",(char *) "diff", NULL
23770 };
23771
23772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23774 if (SWIG_arg_fail(1)) SWIG_fail;
23775 {
23776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23777 if (SWIG_arg_fail(2)) SWIG_fail;
23778 if (arg2 == NULL) {
23779 SWIG_null_ref("wxTimeSpan");
23780 }
23781 if (SWIG_arg_fail(2)) SWIG_fail;
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 {
23786 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23787 result = (wxTimeSpan *) &_result_ref;
23788 }
23789
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23801 PyObject *resultobj;
23802 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23803 int arg2 ;
23804 wxTimeSpan *result;
23805 PyObject * obj0 = 0 ;
23806 PyObject * obj1 = 0 ;
23807 char *kwnames[] = {
23808 (char *) "self",(char *) "n", NULL
23809 };
23810
23811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23813 if (SWIG_arg_fail(1)) SWIG_fail;
23814 {
23815 arg2 = (int)(SWIG_As_int(obj1));
23816 if (SWIG_arg_fail(2)) SWIG_fail;
23817 }
23818 {
23819 PyThreadState* __tstate = wxPyBeginAllowThreads();
23820 {
23821 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23822 result = (wxTimeSpan *) &_result_ref;
23823 }
23824
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23836 PyObject *resultobj;
23837 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23838 wxTimeSpan *result;
23839 PyObject * obj0 = 0 ;
23840 char *kwnames[] = {
23841 (char *) "self", NULL
23842 };
23843
23844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23846 if (SWIG_arg_fail(1)) SWIG_fail;
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 {
23850 wxTimeSpan &_result_ref = (arg1)->Neg();
23851 result = (wxTimeSpan *) &_result_ref;
23852 }
23853
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj;
23866 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23867 wxTimeSpan result;
23868 PyObject * obj0 = 0 ;
23869 char *kwnames[] = {
23870 (char *) "self", NULL
23871 };
23872
23873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23875 if (SWIG_arg_fail(1)) SWIG_fail;
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = ((wxTimeSpan const *)arg1)->Abs();
23879
23880 wxPyEndAllowThreads(__tstate);
23881 if (PyErr_Occurred()) SWIG_fail;
23882 }
23883 {
23884 wxTimeSpan * resultptr;
23885 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23887 }
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23897 wxTimeSpan *arg2 = 0 ;
23898 wxTimeSpan *result;
23899 PyObject * obj0 = 0 ;
23900 PyObject * obj1 = 0 ;
23901 char *kwnames[] = {
23902 (char *) "self",(char *) "diff", NULL
23903 };
23904
23905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23907 if (SWIG_arg_fail(1)) SWIG_fail;
23908 {
23909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23910 if (SWIG_arg_fail(2)) SWIG_fail;
23911 if (arg2 == NULL) {
23912 SWIG_null_ref("wxTimeSpan");
23913 }
23914 if (SWIG_arg_fail(2)) SWIG_fail;
23915 }
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 {
23919 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23920 result = (wxTimeSpan *) &_result_ref;
23921 }
23922
23923 wxPyEndAllowThreads(__tstate);
23924 if (PyErr_Occurred()) SWIG_fail;
23925 }
23926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23927 return resultobj;
23928 fail:
23929 return NULL;
23930 }
23931
23932
23933 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23934 PyObject *resultobj;
23935 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23936 wxTimeSpan *arg2 = 0 ;
23937 wxTimeSpan *result;
23938 PyObject * obj0 = 0 ;
23939 PyObject * obj1 = 0 ;
23940 char *kwnames[] = {
23941 (char *) "self",(char *) "diff", NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23946 if (SWIG_arg_fail(1)) SWIG_fail;
23947 {
23948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23949 if (SWIG_arg_fail(2)) SWIG_fail;
23950 if (arg2 == NULL) {
23951 SWIG_null_ref("wxTimeSpan");
23952 }
23953 if (SWIG_arg_fail(2)) SWIG_fail;
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 {
23958 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23959 result = (wxTimeSpan *) &_result_ref;
23960 }
23961
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23966 return resultobj;
23967 fail:
23968 return NULL;
23969 }
23970
23971
23972 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
23973 PyObject *resultobj;
23974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23975 int arg2 ;
23976 wxTimeSpan *result;
23977 PyObject * obj0 = 0 ;
23978 PyObject * obj1 = 0 ;
23979 char *kwnames[] = {
23980 (char *) "self",(char *) "n", NULL
23981 };
23982
23983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
23984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23985 if (SWIG_arg_fail(1)) SWIG_fail;
23986 {
23987 arg2 = (int)(SWIG_As_int(obj1));
23988 if (SWIG_arg_fail(2)) SWIG_fail;
23989 }
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 {
23993 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
23994 result = (wxTimeSpan *) &_result_ref;
23995 }
23996
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24008 PyObject *resultobj;
24009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24010 wxTimeSpan *result;
24011 PyObject * obj0 = 0 ;
24012 char *kwnames[] = {
24013 (char *) "self", NULL
24014 };
24015
24016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24018 if (SWIG_arg_fail(1)) SWIG_fail;
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 {
24022 wxTimeSpan &_result_ref = (arg1)->operator -();
24023 result = (wxTimeSpan *) &_result_ref;
24024 }
24025
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24030 return resultobj;
24031 fail:
24032 return NULL;
24033 }
24034
24035
24036 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24037 PyObject *resultobj;
24038 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24039 wxTimeSpan *arg2 = 0 ;
24040 wxTimeSpan result;
24041 PyObject * obj0 = 0 ;
24042 PyObject * obj1 = 0 ;
24043 char *kwnames[] = {
24044 (char *) "self",(char *) "other", NULL
24045 };
24046
24047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24049 if (SWIG_arg_fail(1)) SWIG_fail;
24050 {
24051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24052 if (SWIG_arg_fail(2)) SWIG_fail;
24053 if (arg2 == NULL) {
24054 SWIG_null_ref("wxTimeSpan");
24055 }
24056 if (SWIG_arg_fail(2)) SWIG_fail;
24057 }
24058 {
24059 PyThreadState* __tstate = wxPyBeginAllowThreads();
24060 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24061
24062 wxPyEndAllowThreads(__tstate);
24063 if (PyErr_Occurred()) SWIG_fail;
24064 }
24065 {
24066 wxTimeSpan * resultptr;
24067 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24068 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24069 }
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj;
24078 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24079 wxTimeSpan *arg2 = 0 ;
24080 wxTimeSpan result;
24081 PyObject * obj0 = 0 ;
24082 PyObject * obj1 = 0 ;
24083 char *kwnames[] = {
24084 (char *) "self",(char *) "other", NULL
24085 };
24086
24087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24089 if (SWIG_arg_fail(1)) SWIG_fail;
24090 {
24091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24092 if (SWIG_arg_fail(2)) SWIG_fail;
24093 if (arg2 == NULL) {
24094 SWIG_null_ref("wxTimeSpan");
24095 }
24096 if (SWIG_arg_fail(2)) SWIG_fail;
24097 }
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24101
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 {
24106 wxTimeSpan * resultptr;
24107 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24109 }
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24119 int arg2 ;
24120 wxTimeSpan result;
24121 PyObject * obj0 = 0 ;
24122 PyObject * obj1 = 0 ;
24123 char *kwnames[] = {
24124 (char *) "self",(char *) "n", NULL
24125 };
24126
24127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24129 if (SWIG_arg_fail(1)) SWIG_fail;
24130 {
24131 arg2 = (int)(SWIG_As_int(obj1));
24132 if (SWIG_arg_fail(2)) SWIG_fail;
24133 }
24134 {
24135 PyThreadState* __tstate = wxPyBeginAllowThreads();
24136 result = wxTimeSpan___mul__(arg1,arg2);
24137
24138 wxPyEndAllowThreads(__tstate);
24139 if (PyErr_Occurred()) SWIG_fail;
24140 }
24141 {
24142 wxTimeSpan * resultptr;
24143 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24145 }
24146 return resultobj;
24147 fail:
24148 return NULL;
24149 }
24150
24151
24152 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24153 PyObject *resultobj;
24154 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24155 int arg2 ;
24156 wxTimeSpan result;
24157 PyObject * obj0 = 0 ;
24158 PyObject * obj1 = 0 ;
24159 char *kwnames[] = {
24160 (char *) "self",(char *) "n", NULL
24161 };
24162
24163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24165 if (SWIG_arg_fail(1)) SWIG_fail;
24166 {
24167 arg2 = (int)(SWIG_As_int(obj1));
24168 if (SWIG_arg_fail(2)) SWIG_fail;
24169 }
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 result = wxTimeSpan___rmul__(arg1,arg2);
24173
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 {
24178 wxTimeSpan * resultptr;
24179 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24181 }
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24189 PyObject *resultobj;
24190 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24191 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24192 bool result;
24193 PyObject * obj0 = 0 ;
24194 PyObject * obj1 = 0 ;
24195 char *kwnames[] = {
24196 (char *) "self",(char *) "other", NULL
24197 };
24198
24199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24201 if (SWIG_arg_fail(1)) SWIG_fail;
24202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24203 if (SWIG_arg_fail(2)) SWIG_fail;
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24207
24208 wxPyEndAllowThreads(__tstate);
24209 if (PyErr_Occurred()) SWIG_fail;
24210 }
24211 {
24212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24213 }
24214 return resultobj;
24215 fail:
24216 return NULL;
24217 }
24218
24219
24220 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24221 PyObject *resultobj;
24222 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24223 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24224 bool result;
24225 PyObject * obj0 = 0 ;
24226 PyObject * obj1 = 0 ;
24227 char *kwnames[] = {
24228 (char *) "self",(char *) "other", NULL
24229 };
24230
24231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24233 if (SWIG_arg_fail(1)) SWIG_fail;
24234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(2)) SWIG_fail;
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24239
24240 wxPyEndAllowThreads(__tstate);
24241 if (PyErr_Occurred()) SWIG_fail;
24242 }
24243 {
24244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24245 }
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj;
24254 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24255 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24256 bool result;
24257 PyObject * obj0 = 0 ;
24258 PyObject * obj1 = 0 ;
24259 char *kwnames[] = {
24260 (char *) "self",(char *) "other", NULL
24261 };
24262
24263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24265 if (SWIG_arg_fail(1)) SWIG_fail;
24266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24267 if (SWIG_arg_fail(2)) SWIG_fail;
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24271
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 {
24276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24277 }
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj;
24286 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24287 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24288 bool result;
24289 PyObject * obj0 = 0 ;
24290 PyObject * obj1 = 0 ;
24291 char *kwnames[] = {
24292 (char *) "self",(char *) "other", NULL
24293 };
24294
24295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24297 if (SWIG_arg_fail(1)) SWIG_fail;
24298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24299 if (SWIG_arg_fail(2)) SWIG_fail;
24300 {
24301 PyThreadState* __tstate = wxPyBeginAllowThreads();
24302 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24303
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 {
24308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24309 }
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj;
24318 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24319 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24320 bool result;
24321 PyObject * obj0 = 0 ;
24322 PyObject * obj1 = 0 ;
24323 char *kwnames[] = {
24324 (char *) "self",(char *) "other", NULL
24325 };
24326
24327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24329 if (SWIG_arg_fail(1)) SWIG_fail;
24330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24331 if (SWIG_arg_fail(2)) SWIG_fail;
24332 {
24333 PyThreadState* __tstate = wxPyBeginAllowThreads();
24334 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24335
24336 wxPyEndAllowThreads(__tstate);
24337 if (PyErr_Occurred()) SWIG_fail;
24338 }
24339 {
24340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24341 }
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj;
24350 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24351 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24352 bool result;
24353 PyObject * obj0 = 0 ;
24354 PyObject * obj1 = 0 ;
24355 char *kwnames[] = {
24356 (char *) "self",(char *) "other", NULL
24357 };
24358
24359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24361 if (SWIG_arg_fail(1)) SWIG_fail;
24362 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24363 if (SWIG_arg_fail(2)) SWIG_fail;
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24367
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 {
24372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24373 }
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj;
24382 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24383 bool result;
24384 PyObject * obj0 = 0 ;
24385 char *kwnames[] = {
24386 (char *) "self", NULL
24387 };
24388
24389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24391 if (SWIG_arg_fail(1)) SWIG_fail;
24392 {
24393 PyThreadState* __tstate = wxPyBeginAllowThreads();
24394 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24395
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 {
24400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24401 }
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24409 PyObject *resultobj;
24410 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24411 bool result;
24412 PyObject * obj0 = 0 ;
24413 char *kwnames[] = {
24414 (char *) "self", NULL
24415 };
24416
24417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24419 if (SWIG_arg_fail(1)) SWIG_fail;
24420 {
24421 PyThreadState* __tstate = wxPyBeginAllowThreads();
24422 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24423
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 {
24428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24429 }
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24437 PyObject *resultobj;
24438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24439 bool result;
24440 PyObject * obj0 = 0 ;
24441 char *kwnames[] = {
24442 (char *) "self", NULL
24443 };
24444
24445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24447 if (SWIG_arg_fail(1)) SWIG_fail;
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24451
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 {
24456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24457 }
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24465 PyObject *resultobj;
24466 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24467 wxTimeSpan *arg2 = 0 ;
24468 bool result;
24469 PyObject * obj0 = 0 ;
24470 PyObject * obj1 = 0 ;
24471 char *kwnames[] = {
24472 (char *) "self",(char *) "ts", NULL
24473 };
24474
24475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24477 if (SWIG_arg_fail(1)) SWIG_fail;
24478 {
24479 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24480 if (SWIG_arg_fail(2)) SWIG_fail;
24481 if (arg2 == NULL) {
24482 SWIG_null_ref("wxTimeSpan");
24483 }
24484 if (SWIG_arg_fail(2)) SWIG_fail;
24485 }
24486 {
24487 PyThreadState* __tstate = wxPyBeginAllowThreads();
24488 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24489
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 {
24494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24495 }
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24503 PyObject *resultobj;
24504 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24505 wxTimeSpan *arg2 = 0 ;
24506 bool result;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "self",(char *) "ts", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(1)) SWIG_fail;
24516 {
24517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24518 if (SWIG_arg_fail(2)) SWIG_fail;
24519 if (arg2 == NULL) {
24520 SWIG_null_ref("wxTimeSpan");
24521 }
24522 if (SWIG_arg_fail(2)) SWIG_fail;
24523 }
24524 {
24525 PyThreadState* __tstate = wxPyBeginAllowThreads();
24526 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24527
24528 wxPyEndAllowThreads(__tstate);
24529 if (PyErr_Occurred()) SWIG_fail;
24530 }
24531 {
24532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24533 }
24534 return resultobj;
24535 fail:
24536 return NULL;
24537 }
24538
24539
24540 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj;
24542 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24543 wxTimeSpan *arg2 = 0 ;
24544 bool result;
24545 PyObject * obj0 = 0 ;
24546 PyObject * obj1 = 0 ;
24547 char *kwnames[] = {
24548 (char *) "self",(char *) "t", NULL
24549 };
24550
24551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24553 if (SWIG_arg_fail(1)) SWIG_fail;
24554 {
24555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24556 if (SWIG_arg_fail(2)) SWIG_fail;
24557 if (arg2 == NULL) {
24558 SWIG_null_ref("wxTimeSpan");
24559 }
24560 if (SWIG_arg_fail(2)) SWIG_fail;
24561 }
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 {
24570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24571 }
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24581 int result;
24582 PyObject * obj0 = 0 ;
24583 char *kwnames[] = {
24584 (char *) "self", NULL
24585 };
24586
24587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(1)) SWIG_fail;
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 {
24598 resultobj = SWIG_From_int((int)(result));
24599 }
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj;
24608 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24609 int result;
24610 PyObject * obj0 = 0 ;
24611 char *kwnames[] = {
24612 (char *) "self", NULL
24613 };
24614
24615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24617 if (SWIG_arg_fail(1)) SWIG_fail;
24618 {
24619 PyThreadState* __tstate = wxPyBeginAllowThreads();
24620 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24621
24622 wxPyEndAllowThreads(__tstate);
24623 if (PyErr_Occurred()) SWIG_fail;
24624 }
24625 {
24626 resultobj = SWIG_From_int((int)(result));
24627 }
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj;
24636 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24637 int result;
24638 PyObject * obj0 = 0 ;
24639 char *kwnames[] = {
24640 (char *) "self", NULL
24641 };
24642
24643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24645 if (SWIG_arg_fail(1)) SWIG_fail;
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24649
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 {
24654 resultobj = SWIG_From_int((int)(result));
24655 }
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj;
24664 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24665 int result;
24666 PyObject * obj0 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24677
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 resultobj = SWIG_From_int((int)(result));
24683 }
24684 return resultobj;
24685 fail:
24686 return NULL;
24687 }
24688
24689
24690 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24691 PyObject *resultobj;
24692 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24693 wxLongLong result;
24694 PyObject * obj0 = 0 ;
24695 char *kwnames[] = {
24696 (char *) "self", NULL
24697 };
24698
24699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24701 if (SWIG_arg_fail(1)) SWIG_fail;
24702 {
24703 PyThreadState* __tstate = wxPyBeginAllowThreads();
24704 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24705
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 {
24710 PyObject *hi, *lo, *shifter, *shifted;
24711 hi = PyLong_FromLong( (&result)->GetHi() );
24712 lo = PyLong_FromLong( (&result)->GetLo() );
24713 shifter = PyLong_FromLong(32);
24714 shifted = PyNumber_Lshift(hi, shifter);
24715 resultobj = PyNumber_Or(shifted, lo);
24716 Py_DECREF(hi);
24717 Py_DECREF(lo);
24718 Py_DECREF(shifter);
24719 Py_DECREF(shifted);
24720 }
24721 return resultobj;
24722 fail:
24723 return NULL;
24724 }
24725
24726
24727 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24728 PyObject *resultobj;
24729 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24730 wxLongLong result;
24731 PyObject * obj0 = 0 ;
24732 char *kwnames[] = {
24733 (char *) "self", NULL
24734 };
24735
24736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24738 if (SWIG_arg_fail(1)) SWIG_fail;
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24742
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 {
24747 PyObject *hi, *lo, *shifter, *shifted;
24748 hi = PyLong_FromLong( (&result)->GetHi() );
24749 lo = PyLong_FromLong( (&result)->GetLo() );
24750 shifter = PyLong_FromLong(32);
24751 shifted = PyNumber_Lshift(hi, shifter);
24752 resultobj = PyNumber_Or(shifted, lo);
24753 Py_DECREF(hi);
24754 Py_DECREF(lo);
24755 Py_DECREF(shifter);
24756 Py_DECREF(shifted);
24757 }
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24767 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24768 wxString *arg2 = (wxString *) &arg2_defvalue ;
24769 wxString result;
24770 bool temp2 = false ;
24771 PyObject * obj0 = 0 ;
24772 PyObject * obj1 = 0 ;
24773 char *kwnames[] = {
24774 (char *) "self",(char *) "format", NULL
24775 };
24776
24777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24779 if (SWIG_arg_fail(1)) SWIG_fail;
24780 if (obj1) {
24781 {
24782 arg2 = wxString_in_helper(obj1);
24783 if (arg2 == NULL) SWIG_fail;
24784 temp2 = true;
24785 }
24786 }
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 #if wxUSE_UNICODE
24796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24797 #else
24798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24799 #endif
24800 }
24801 {
24802 if (temp2)
24803 delete arg2;
24804 }
24805 return resultobj;
24806 fail:
24807 {
24808 if (temp2)
24809 delete arg2;
24810 }
24811 return NULL;
24812 }
24813
24814
24815 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24816 PyObject *obj;
24817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24818 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24819 Py_INCREF(obj);
24820 return Py_BuildValue((char *)"");
24821 }
24822 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24823 PyObject *resultobj;
24824 int arg1 = (int) 0 ;
24825 int arg2 = (int) 0 ;
24826 int arg3 = (int) 0 ;
24827 int arg4 = (int) 0 ;
24828 wxDateSpan *result;
24829 PyObject * obj0 = 0 ;
24830 PyObject * obj1 = 0 ;
24831 PyObject * obj2 = 0 ;
24832 PyObject * obj3 = 0 ;
24833 char *kwnames[] = {
24834 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24838 if (obj0) {
24839 {
24840 arg1 = (int)(SWIG_As_int(obj0));
24841 if (SWIG_arg_fail(1)) SWIG_fail;
24842 }
24843 }
24844 if (obj1) {
24845 {
24846 arg2 = (int)(SWIG_As_int(obj1));
24847 if (SWIG_arg_fail(2)) SWIG_fail;
24848 }
24849 }
24850 if (obj2) {
24851 {
24852 arg3 = (int)(SWIG_As_int(obj2));
24853 if (SWIG_arg_fail(3)) SWIG_fail;
24854 }
24855 }
24856 if (obj3) {
24857 {
24858 arg4 = (int)(SWIG_As_int(obj3));
24859 if (SWIG_arg_fail(4)) SWIG_fail;
24860 }
24861 }
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24865
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24877 PyObject *resultobj;
24878 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24879 PyObject * obj0 = 0 ;
24880 char *kwnames[] = {
24881 (char *) "self", NULL
24882 };
24883
24884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24886 if (SWIG_arg_fail(1)) SWIG_fail;
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 delete arg1;
24890
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 Py_INCREF(Py_None); resultobj = Py_None;
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24902 PyObject *resultobj;
24903 int arg1 ;
24904 wxDateSpan result;
24905 PyObject * obj0 = 0 ;
24906 char *kwnames[] = {
24907 (char *) "days", NULL
24908 };
24909
24910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24911 {
24912 arg1 = (int)(SWIG_As_int(obj0));
24913 if (SWIG_arg_fail(1)) SWIG_fail;
24914 }
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 result = wxDateSpan::Days(arg1);
24918
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 {
24923 wxDateSpan * resultptr;
24924 resultptr = new wxDateSpan((wxDateSpan &)(result));
24925 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24926 }
24927 return resultobj;
24928 fail:
24929 return NULL;
24930 }
24931
24932
24933 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24934 PyObject *resultobj;
24935 wxDateSpan result;
24936 char *kwnames[] = {
24937 NULL
24938 };
24939
24940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = wxDateSpan::Day();
24944
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 wxDateSpan * resultptr;
24950 resultptr = new wxDateSpan((wxDateSpan &)(result));
24951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24952 }
24953 return resultobj;
24954 fail:
24955 return NULL;
24956 }
24957
24958
24959 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24960 PyObject *resultobj;
24961 int arg1 ;
24962 wxDateSpan result;
24963 PyObject * obj0 = 0 ;
24964 char *kwnames[] = {
24965 (char *) "weeks", NULL
24966 };
24967
24968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
24969 {
24970 arg1 = (int)(SWIG_As_int(obj0));
24971 if (SWIG_arg_fail(1)) SWIG_fail;
24972 }
24973 {
24974 PyThreadState* __tstate = wxPyBeginAllowThreads();
24975 result = wxDateSpan::Weeks(arg1);
24976
24977 wxPyEndAllowThreads(__tstate);
24978 if (PyErr_Occurred()) SWIG_fail;
24979 }
24980 {
24981 wxDateSpan * resultptr;
24982 resultptr = new wxDateSpan((wxDateSpan &)(result));
24983 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24984 }
24985 return resultobj;
24986 fail:
24987 return NULL;
24988 }
24989
24990
24991 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24992 PyObject *resultobj;
24993 wxDateSpan result;
24994 char *kwnames[] = {
24995 NULL
24996 };
24997
24998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = wxDateSpan::Week();
25002
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 {
25007 wxDateSpan * resultptr;
25008 resultptr = new wxDateSpan((wxDateSpan &)(result));
25009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25010 }
25011 return resultobj;
25012 fail:
25013 return NULL;
25014 }
25015
25016
25017 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25018 PyObject *resultobj;
25019 int arg1 ;
25020 wxDateSpan result;
25021 PyObject * obj0 = 0 ;
25022 char *kwnames[] = {
25023 (char *) "mon", NULL
25024 };
25025
25026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25027 {
25028 arg1 = (int)(SWIG_As_int(obj0));
25029 if (SWIG_arg_fail(1)) SWIG_fail;
25030 }
25031 {
25032 PyThreadState* __tstate = wxPyBeginAllowThreads();
25033 result = wxDateSpan::Months(arg1);
25034
25035 wxPyEndAllowThreads(__tstate);
25036 if (PyErr_Occurred()) SWIG_fail;
25037 }
25038 {
25039 wxDateSpan * resultptr;
25040 resultptr = new wxDateSpan((wxDateSpan &)(result));
25041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj;
25051 wxDateSpan result;
25052 char *kwnames[] = {
25053 NULL
25054 };
25055
25056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25057 {
25058 PyThreadState* __tstate = wxPyBeginAllowThreads();
25059 result = wxDateSpan::Month();
25060
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 {
25065 wxDateSpan * resultptr;
25066 resultptr = new wxDateSpan((wxDateSpan &)(result));
25067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25068 }
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj;
25077 int arg1 ;
25078 wxDateSpan result;
25079 PyObject * obj0 = 0 ;
25080 char *kwnames[] = {
25081 (char *) "years", NULL
25082 };
25083
25084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25085 {
25086 arg1 = (int)(SWIG_As_int(obj0));
25087 if (SWIG_arg_fail(1)) SWIG_fail;
25088 }
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = wxDateSpan::Years(arg1);
25092
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 wxDateSpan * resultptr;
25098 resultptr = new wxDateSpan((wxDateSpan &)(result));
25099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25100 }
25101 return resultobj;
25102 fail:
25103 return NULL;
25104 }
25105
25106
25107 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj;
25109 wxDateSpan result;
25110 char *kwnames[] = {
25111 NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = wxDateSpan::Year();
25118
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 wxDateSpan * resultptr;
25124 resultptr = new wxDateSpan((wxDateSpan &)(result));
25125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25126 }
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj;
25135 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25136 int arg2 ;
25137 wxDateSpan *result;
25138 PyObject * obj0 = 0 ;
25139 PyObject * obj1 = 0 ;
25140 char *kwnames[] = {
25141 (char *) "self",(char *) "n", NULL
25142 };
25143
25144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25146 if (SWIG_arg_fail(1)) SWIG_fail;
25147 {
25148 arg2 = (int)(SWIG_As_int(obj1));
25149 if (SWIG_arg_fail(2)) SWIG_fail;
25150 }
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 {
25154 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25155 result = (wxDateSpan *) &_result_ref;
25156 }
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj;
25170 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25171 int arg2 ;
25172 wxDateSpan *result;
25173 PyObject * obj0 = 0 ;
25174 PyObject * obj1 = 0 ;
25175 char *kwnames[] = {
25176 (char *) "self",(char *) "n", NULL
25177 };
25178
25179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25181 if (SWIG_arg_fail(1)) SWIG_fail;
25182 {
25183 arg2 = (int)(SWIG_As_int(obj1));
25184 if (SWIG_arg_fail(2)) SWIG_fail;
25185 }
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 {
25189 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25190 result = (wxDateSpan *) &_result_ref;
25191 }
25192
25193 wxPyEndAllowThreads(__tstate);
25194 if (PyErr_Occurred()) SWIG_fail;
25195 }
25196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25197 return resultobj;
25198 fail:
25199 return NULL;
25200 }
25201
25202
25203 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25204 PyObject *resultobj;
25205 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25206 int arg2 ;
25207 wxDateSpan *result;
25208 PyObject * obj0 = 0 ;
25209 PyObject * obj1 = 0 ;
25210 char *kwnames[] = {
25211 (char *) "self",(char *) "n", NULL
25212 };
25213
25214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25216 if (SWIG_arg_fail(1)) SWIG_fail;
25217 {
25218 arg2 = (int)(SWIG_As_int(obj1));
25219 if (SWIG_arg_fail(2)) SWIG_fail;
25220 }
25221 {
25222 PyThreadState* __tstate = wxPyBeginAllowThreads();
25223 {
25224 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25225 result = (wxDateSpan *) &_result_ref;
25226 }
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25232 return resultobj;
25233 fail:
25234 return NULL;
25235 }
25236
25237
25238 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25239 PyObject *resultobj;
25240 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25241 int arg2 ;
25242 wxDateSpan *result;
25243 PyObject * obj0 = 0 ;
25244 PyObject * obj1 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "self",(char *) "n", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25251 if (SWIG_arg_fail(1)) SWIG_fail;
25252 {
25253 arg2 = (int)(SWIG_As_int(obj1));
25254 if (SWIG_arg_fail(2)) SWIG_fail;
25255 }
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 {
25259 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25260 result = (wxDateSpan *) &_result_ref;
25261 }
25262
25263 wxPyEndAllowThreads(__tstate);
25264 if (PyErr_Occurred()) SWIG_fail;
25265 }
25266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25267 return resultobj;
25268 fail:
25269 return NULL;
25270 }
25271
25272
25273 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25274 PyObject *resultobj;
25275 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25276 int result;
25277 PyObject * obj0 = 0 ;
25278 char *kwnames[] = {
25279 (char *) "self", NULL
25280 };
25281
25282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25284 if (SWIG_arg_fail(1)) SWIG_fail;
25285 {
25286 PyThreadState* __tstate = wxPyBeginAllowThreads();
25287 result = (int)((wxDateSpan const *)arg1)->GetYears();
25288
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 {
25293 resultobj = SWIG_From_int((int)(result));
25294 }
25295 return resultobj;
25296 fail:
25297 return NULL;
25298 }
25299
25300
25301 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj;
25303 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25304 int result;
25305 PyObject * obj0 = 0 ;
25306 char *kwnames[] = {
25307 (char *) "self", NULL
25308 };
25309
25310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25312 if (SWIG_arg_fail(1)) SWIG_fail;
25313 {
25314 PyThreadState* __tstate = wxPyBeginAllowThreads();
25315 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25316
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 {
25321 resultobj = SWIG_From_int((int)(result));
25322 }
25323 return resultobj;
25324 fail:
25325 return NULL;
25326 }
25327
25328
25329 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25330 PyObject *resultobj;
25331 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25332 int result;
25333 PyObject * obj0 = 0 ;
25334 char *kwnames[] = {
25335 (char *) "self", NULL
25336 };
25337
25338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25340 if (SWIG_arg_fail(1)) SWIG_fail;
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25344
25345 wxPyEndAllowThreads(__tstate);
25346 if (PyErr_Occurred()) SWIG_fail;
25347 }
25348 {
25349 resultobj = SWIG_From_int((int)(result));
25350 }
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj;
25359 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25360 int result;
25361 PyObject * obj0 = 0 ;
25362 char *kwnames[] = {
25363 (char *) "self", NULL
25364 };
25365
25366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25368 if (SWIG_arg_fail(1)) SWIG_fail;
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 result = (int)((wxDateSpan const *)arg1)->GetDays();
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 {
25377 resultobj = SWIG_From_int((int)(result));
25378 }
25379 return resultobj;
25380 fail:
25381 return NULL;
25382 }
25383
25384
25385 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25386 PyObject *resultobj;
25387 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25388 int result;
25389 PyObject * obj0 = 0 ;
25390 char *kwnames[] = {
25391 (char *) "self", NULL
25392 };
25393
25394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 {
25398 PyThreadState* __tstate = wxPyBeginAllowThreads();
25399 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25400
25401 wxPyEndAllowThreads(__tstate);
25402 if (PyErr_Occurred()) SWIG_fail;
25403 }
25404 {
25405 resultobj = SWIG_From_int((int)(result));
25406 }
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj;
25415 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25416 wxDateSpan *arg2 = 0 ;
25417 wxDateSpan *result;
25418 PyObject * obj0 = 0 ;
25419 PyObject * obj1 = 0 ;
25420 char *kwnames[] = {
25421 (char *) "self",(char *) "other", NULL
25422 };
25423
25424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25426 if (SWIG_arg_fail(1)) SWIG_fail;
25427 {
25428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25429 if (SWIG_arg_fail(2)) SWIG_fail;
25430 if (arg2 == NULL) {
25431 SWIG_null_ref("wxDateSpan");
25432 }
25433 if (SWIG_arg_fail(2)) SWIG_fail;
25434 }
25435 {
25436 PyThreadState* __tstate = wxPyBeginAllowThreads();
25437 {
25438 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25439 result = (wxDateSpan *) &_result_ref;
25440 }
25441
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25453 PyObject *resultobj;
25454 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25455 wxDateSpan *arg2 = 0 ;
25456 wxDateSpan *result;
25457 PyObject * obj0 = 0 ;
25458 PyObject * obj1 = 0 ;
25459 char *kwnames[] = {
25460 (char *) "self",(char *) "other", NULL
25461 };
25462
25463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25465 if (SWIG_arg_fail(1)) SWIG_fail;
25466 {
25467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25468 if (SWIG_arg_fail(2)) SWIG_fail;
25469 if (arg2 == NULL) {
25470 SWIG_null_ref("wxDateSpan");
25471 }
25472 if (SWIG_arg_fail(2)) SWIG_fail;
25473 }
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 {
25477 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25478 result = (wxDateSpan *) &_result_ref;
25479 }
25480
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25494 wxDateSpan *result;
25495 PyObject * obj0 = 0 ;
25496 char *kwnames[] = {
25497 (char *) "self", NULL
25498 };
25499
25500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25502 if (SWIG_arg_fail(1)) SWIG_fail;
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 {
25506 wxDateSpan &_result_ref = (arg1)->Neg();
25507 result = (wxDateSpan *) &_result_ref;
25508 }
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj;
25522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25523 int arg2 ;
25524 wxDateSpan *result;
25525 PyObject * obj0 = 0 ;
25526 PyObject * obj1 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self",(char *) "factor", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 arg2 = (int)(SWIG_As_int(obj1));
25536 if (SWIG_arg_fail(2)) SWIG_fail;
25537 }
25538 {
25539 PyThreadState* __tstate = wxPyBeginAllowThreads();
25540 {
25541 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25542 result = (wxDateSpan *) &_result_ref;
25543 }
25544
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25556 PyObject *resultobj;
25557 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25558 wxDateSpan *arg2 = 0 ;
25559 wxDateSpan *result;
25560 PyObject * obj0 = 0 ;
25561 PyObject * obj1 = 0 ;
25562 char *kwnames[] = {
25563 (char *) "self",(char *) "other", NULL
25564 };
25565
25566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25568 if (SWIG_arg_fail(1)) SWIG_fail;
25569 {
25570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25571 if (SWIG_arg_fail(2)) SWIG_fail;
25572 if (arg2 == NULL) {
25573 SWIG_null_ref("wxDateSpan");
25574 }
25575 if (SWIG_arg_fail(2)) SWIG_fail;
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 {
25580 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25581 result = (wxDateSpan *) &_result_ref;
25582 }
25583
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25595 PyObject *resultobj;
25596 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25597 wxDateSpan *arg2 = 0 ;
25598 wxDateSpan *result;
25599 PyObject * obj0 = 0 ;
25600 PyObject * obj1 = 0 ;
25601 char *kwnames[] = {
25602 (char *) "self",(char *) "other", NULL
25603 };
25604
25605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25607 if (SWIG_arg_fail(1)) SWIG_fail;
25608 {
25609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25610 if (SWIG_arg_fail(2)) SWIG_fail;
25611 if (arg2 == NULL) {
25612 SWIG_null_ref("wxDateSpan");
25613 }
25614 if (SWIG_arg_fail(2)) SWIG_fail;
25615 }
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 {
25619 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25620 result = (wxDateSpan *) &_result_ref;
25621 }
25622
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25627 return resultobj;
25628 fail:
25629 return NULL;
25630 }
25631
25632
25633 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25634 PyObject *resultobj;
25635 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25636 wxDateSpan *result;
25637 PyObject * obj0 = 0 ;
25638 char *kwnames[] = {
25639 (char *) "self", NULL
25640 };
25641
25642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25644 if (SWIG_arg_fail(1)) SWIG_fail;
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 {
25648 wxDateSpan &_result_ref = (arg1)->operator -();
25649 result = (wxDateSpan *) &_result_ref;
25650 }
25651
25652 wxPyEndAllowThreads(__tstate);
25653 if (PyErr_Occurred()) SWIG_fail;
25654 }
25655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25663 PyObject *resultobj;
25664 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25665 int arg2 ;
25666 wxDateSpan *result;
25667 PyObject * obj0 = 0 ;
25668 PyObject * obj1 = 0 ;
25669 char *kwnames[] = {
25670 (char *) "self",(char *) "factor", NULL
25671 };
25672
25673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25675 if (SWIG_arg_fail(1)) SWIG_fail;
25676 {
25677 arg2 = (int)(SWIG_As_int(obj1));
25678 if (SWIG_arg_fail(2)) SWIG_fail;
25679 }
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 {
25683 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25684 result = (wxDateSpan *) &_result_ref;
25685 }
25686
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25691 return resultobj;
25692 fail:
25693 return NULL;
25694 }
25695
25696
25697 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj;
25699 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25700 wxDateSpan *arg2 = 0 ;
25701 wxDateSpan result;
25702 PyObject * obj0 = 0 ;
25703 PyObject * obj1 = 0 ;
25704 char *kwnames[] = {
25705 (char *) "self",(char *) "other", NULL
25706 };
25707
25708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25710 if (SWIG_arg_fail(1)) SWIG_fail;
25711 {
25712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25713 if (SWIG_arg_fail(2)) SWIG_fail;
25714 if (arg2 == NULL) {
25715 SWIG_null_ref("wxDateSpan");
25716 }
25717 if (SWIG_arg_fail(2)) SWIG_fail;
25718 }
25719 {
25720 PyThreadState* __tstate = wxPyBeginAllowThreads();
25721 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25722
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 {
25727 wxDateSpan * resultptr;
25728 resultptr = new wxDateSpan((wxDateSpan &)(result));
25729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25740 wxDateSpan *arg2 = 0 ;
25741 wxDateSpan result;
25742 PyObject * obj0 = 0 ;
25743 PyObject * obj1 = 0 ;
25744 char *kwnames[] = {
25745 (char *) "self",(char *) "other", NULL
25746 };
25747
25748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25750 if (SWIG_arg_fail(1)) SWIG_fail;
25751 {
25752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25753 if (SWIG_arg_fail(2)) SWIG_fail;
25754 if (arg2 == NULL) {
25755 SWIG_null_ref("wxDateSpan");
25756 }
25757 if (SWIG_arg_fail(2)) SWIG_fail;
25758 }
25759 {
25760 PyThreadState* __tstate = wxPyBeginAllowThreads();
25761 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25762
25763 wxPyEndAllowThreads(__tstate);
25764 if (PyErr_Occurred()) SWIG_fail;
25765 }
25766 {
25767 wxDateSpan * resultptr;
25768 resultptr = new wxDateSpan((wxDateSpan &)(result));
25769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25770 }
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25778 PyObject *resultobj;
25779 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25780 int arg2 ;
25781 wxDateSpan result;
25782 PyObject * obj0 = 0 ;
25783 PyObject * obj1 = 0 ;
25784 char *kwnames[] = {
25785 (char *) "self",(char *) "n", NULL
25786 };
25787
25788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25790 if (SWIG_arg_fail(1)) SWIG_fail;
25791 {
25792 arg2 = (int)(SWIG_As_int(obj1));
25793 if (SWIG_arg_fail(2)) SWIG_fail;
25794 }
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 result = wxDateSpan___mul__(arg1,arg2);
25798
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 {
25803 wxDateSpan * resultptr;
25804 resultptr = new wxDateSpan((wxDateSpan &)(result));
25805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj;
25815 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25816 int arg2 ;
25817 wxDateSpan result;
25818 PyObject * obj0 = 0 ;
25819 PyObject * obj1 = 0 ;
25820 char *kwnames[] = {
25821 (char *) "self",(char *) "n", NULL
25822 };
25823
25824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25826 if (SWIG_arg_fail(1)) SWIG_fail;
25827 {
25828 arg2 = (int)(SWIG_As_int(obj1));
25829 if (SWIG_arg_fail(2)) SWIG_fail;
25830 }
25831 {
25832 PyThreadState* __tstate = wxPyBeginAllowThreads();
25833 result = wxDateSpan___rmul__(arg1,arg2);
25834
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 {
25839 wxDateSpan * resultptr;
25840 resultptr = new wxDateSpan((wxDateSpan &)(result));
25841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25842 }
25843 return resultobj;
25844 fail:
25845 return NULL;
25846 }
25847
25848
25849 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25850 PyObject *resultobj;
25851 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25852 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25853 bool result;
25854 PyObject * obj0 = 0 ;
25855 PyObject * obj1 = 0 ;
25856 char *kwnames[] = {
25857 (char *) "self",(char *) "other", NULL
25858 };
25859
25860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25862 if (SWIG_arg_fail(1)) SWIG_fail;
25863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25864 if (SWIG_arg_fail(2)) SWIG_fail;
25865 {
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25868
25869 wxPyEndAllowThreads(__tstate);
25870 if (PyErr_Occurred()) SWIG_fail;
25871 }
25872 {
25873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25874 }
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj;
25883 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25884 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25885 bool result;
25886 PyObject * obj0 = 0 ;
25887 PyObject * obj1 = 0 ;
25888 char *kwnames[] = {
25889 (char *) "self",(char *) "other", NULL
25890 };
25891
25892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25894 if (SWIG_arg_fail(1)) SWIG_fail;
25895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25896 if (SWIG_arg_fail(2)) SWIG_fail;
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25900
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 {
25905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25906 }
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25914 PyObject *obj;
25915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25916 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25917 Py_INCREF(obj);
25918 return Py_BuildValue((char *)"");
25919 }
25920 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25921 PyObject *resultobj;
25922 long result;
25923 char *kwnames[] = {
25924 NULL
25925 };
25926
25927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 result = (long)wxGetLocalTime();
25931
25932 wxPyEndAllowThreads(__tstate);
25933 if (PyErr_Occurred()) SWIG_fail;
25934 }
25935 {
25936 resultobj = SWIG_From_long((long)(result));
25937 }
25938 return resultobj;
25939 fail:
25940 return NULL;
25941 }
25942
25943
25944 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25945 PyObject *resultobj;
25946 long result;
25947 char *kwnames[] = {
25948 NULL
25949 };
25950
25951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = (long)wxGetUTCTime();
25955
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 {
25960 resultobj = SWIG_From_long((long)(result));
25961 }
25962 return resultobj;
25963 fail:
25964 return NULL;
25965 }
25966
25967
25968 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj;
25970 long result;
25971 char *kwnames[] = {
25972 NULL
25973 };
25974
25975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 result = (long)wxGetCurrentTime();
25979
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 {
25984 resultobj = SWIG_From_long((long)(result));
25985 }
25986 return resultobj;
25987 fail:
25988 return NULL;
25989 }
25990
25991
25992 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
25993 PyObject *resultobj;
25994 wxLongLong result;
25995 char *kwnames[] = {
25996 NULL
25997 };
25998
25999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 result = wxGetLocalTimeMillis();
26003
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 {
26008 PyObject *hi, *lo, *shifter, *shifted;
26009 hi = PyLong_FromLong( (&result)->GetHi() );
26010 lo = PyLong_FromLong( (&result)->GetLo() );
26011 shifter = PyLong_FromLong(32);
26012 shifted = PyNumber_Lshift(hi, shifter);
26013 resultobj = PyNumber_Or(shifted, lo);
26014 Py_DECREF(hi);
26015 Py_DECREF(lo);
26016 Py_DECREF(shifter);
26017 Py_DECREF(shifted);
26018 }
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 static int _wrap_DefaultDateTime_set(PyObject *) {
26026 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26027 return 1;
26028 }
26029
26030
26031 static PyObject *_wrap_DefaultDateTime_get(void) {
26032 PyObject *pyobj;
26033
26034 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26035 return pyobj;
26036 }
26037
26038
26039 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26040 PyObject *resultobj;
26041 wxDataFormatId arg1 ;
26042 wxDataFormat *result;
26043 PyObject * obj0 = 0 ;
26044 char *kwnames[] = {
26045 (char *) "type", NULL
26046 };
26047
26048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26049 {
26050 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26051 if (SWIG_arg_fail(1)) SWIG_fail;
26052 }
26053 {
26054 PyThreadState* __tstate = wxPyBeginAllowThreads();
26055 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26056
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26061 return resultobj;
26062 fail:
26063 return NULL;
26064 }
26065
26066
26067 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj;
26069 wxString *arg1 = 0 ;
26070 wxDataFormat *result;
26071 bool temp1 = false ;
26072 PyObject * obj0 = 0 ;
26073 char *kwnames[] = {
26074 (char *) "format", NULL
26075 };
26076
26077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26078 {
26079 arg1 = wxString_in_helper(obj0);
26080 if (arg1 == NULL) SWIG_fail;
26081 temp1 = true;
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26091 {
26092 if (temp1)
26093 delete arg1;
26094 }
26095 return resultobj;
26096 fail:
26097 {
26098 if (temp1)
26099 delete arg1;
26100 }
26101 return NULL;
26102 }
26103
26104
26105 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26106 PyObject *resultobj;
26107 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26108 PyObject * obj0 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 delete arg1;
26119
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 Py_INCREF(Py_None); resultobj = Py_None;
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26131 PyObject *resultobj;
26132 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26133 wxDataFormatId arg2 ;
26134 bool result;
26135 PyObject * obj0 = 0 ;
26136 PyObject * obj1 = 0 ;
26137
26138 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26140 if (SWIG_arg_fail(1)) SWIG_fail;
26141 {
26142 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26143 if (SWIG_arg_fail(2)) SWIG_fail;
26144 }
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26148
26149 wxPyEndAllowThreads(__tstate);
26150 if (PyErr_Occurred()) SWIG_fail;
26151 }
26152 {
26153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26154 }
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26162 PyObject *resultobj;
26163 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26164 wxDataFormatId arg2 ;
26165 bool result;
26166 PyObject * obj0 = 0 ;
26167 PyObject * obj1 = 0 ;
26168
26169 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26171 if (SWIG_arg_fail(1)) SWIG_fail;
26172 {
26173 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26174 if (SWIG_arg_fail(2)) SWIG_fail;
26175 }
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26179
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 {
26184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26185 }
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26193 PyObject *resultobj;
26194 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26195 wxDataFormat *arg2 = 0 ;
26196 bool result;
26197 PyObject * obj0 = 0 ;
26198 PyObject * obj1 = 0 ;
26199
26200 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26202 if (SWIG_arg_fail(1)) SWIG_fail;
26203 {
26204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26205 if (SWIG_arg_fail(2)) SWIG_fail;
26206 if (arg2 == NULL) {
26207 SWIG_null_ref("wxDataFormat");
26208 }
26209 if (SWIG_arg_fail(2)) SWIG_fail;
26210 }
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26214
26215 wxPyEndAllowThreads(__tstate);
26216 if (PyErr_Occurred()) SWIG_fail;
26217 }
26218 {
26219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26220 }
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26228 int argc;
26229 PyObject *argv[3];
26230 int ii;
26231
26232 argc = PyObject_Length(args);
26233 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26234 argv[ii] = PyTuple_GetItem(args,ii);
26235 }
26236 if (argc == 2) {
26237 int _v;
26238 {
26239 void *ptr;
26240 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26241 _v = 0;
26242 PyErr_Clear();
26243 } else {
26244 _v = 1;
26245 }
26246 }
26247 if (_v) {
26248 {
26249 void *ptr = 0;
26250 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26251 _v = 0;
26252 PyErr_Clear();
26253 } else {
26254 _v = (ptr != 0);
26255 }
26256 }
26257 if (_v) {
26258 return _wrap_DataFormat___eq____SWIG_1(self,args);
26259 }
26260 }
26261 }
26262 if (argc == 2) {
26263 int _v;
26264 {
26265 void *ptr;
26266 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26267 _v = 0;
26268 PyErr_Clear();
26269 } else {
26270 _v = 1;
26271 }
26272 }
26273 if (_v) {
26274 _v = SWIG_Check_int(argv[1]);
26275 if (_v) {
26276 return _wrap_DataFormat___eq____SWIG_0(self,args);
26277 }
26278 }
26279 }
26280
26281 Py_INCREF(Py_NotImplemented);
26282 return Py_NotImplemented;
26283 }
26284
26285
26286 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26287 PyObject *resultobj;
26288 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26289 wxDataFormat *arg2 = 0 ;
26290 bool result;
26291 PyObject * obj0 = 0 ;
26292 PyObject * obj1 = 0 ;
26293
26294 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26296 if (SWIG_arg_fail(1)) SWIG_fail;
26297 {
26298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26299 if (SWIG_arg_fail(2)) SWIG_fail;
26300 if (arg2 == NULL) {
26301 SWIG_null_ref("wxDataFormat");
26302 }
26303 if (SWIG_arg_fail(2)) SWIG_fail;
26304 }
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26308
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 {
26313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26314 }
26315 return resultobj;
26316 fail:
26317 return NULL;
26318 }
26319
26320
26321 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26322 int argc;
26323 PyObject *argv[3];
26324 int ii;
26325
26326 argc = PyObject_Length(args);
26327 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26328 argv[ii] = PyTuple_GetItem(args,ii);
26329 }
26330 if (argc == 2) {
26331 int _v;
26332 {
26333 void *ptr;
26334 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26335 _v = 0;
26336 PyErr_Clear();
26337 } else {
26338 _v = 1;
26339 }
26340 }
26341 if (_v) {
26342 {
26343 void *ptr = 0;
26344 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26345 _v = 0;
26346 PyErr_Clear();
26347 } else {
26348 _v = (ptr != 0);
26349 }
26350 }
26351 if (_v) {
26352 return _wrap_DataFormat___ne____SWIG_1(self,args);
26353 }
26354 }
26355 }
26356 if (argc == 2) {
26357 int _v;
26358 {
26359 void *ptr;
26360 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26361 _v = 0;
26362 PyErr_Clear();
26363 } else {
26364 _v = 1;
26365 }
26366 }
26367 if (_v) {
26368 _v = SWIG_Check_int(argv[1]);
26369 if (_v) {
26370 return _wrap_DataFormat___ne____SWIG_0(self,args);
26371 }
26372 }
26373 }
26374
26375 Py_INCREF(Py_NotImplemented);
26376 return Py_NotImplemented;
26377 }
26378
26379
26380 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj;
26382 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26383 wxDataFormatId arg2 ;
26384 PyObject * obj0 = 0 ;
26385 PyObject * obj1 = 0 ;
26386 char *kwnames[] = {
26387 (char *) "self",(char *) "format", NULL
26388 };
26389
26390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26392 if (SWIG_arg_fail(1)) SWIG_fail;
26393 {
26394 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26395 if (SWIG_arg_fail(2)) SWIG_fail;
26396 }
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 (arg1)->SetType((wxDataFormatId )arg2);
26400
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 Py_INCREF(Py_None); resultobj = Py_None;
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26412 PyObject *resultobj;
26413 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26414 wxDataFormatId result;
26415 PyObject * obj0 = 0 ;
26416 char *kwnames[] = {
26417 (char *) "self", NULL
26418 };
26419
26420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26422 if (SWIG_arg_fail(1)) SWIG_fail;
26423 {
26424 PyThreadState* __tstate = wxPyBeginAllowThreads();
26425 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26426
26427 wxPyEndAllowThreads(__tstate);
26428 if (PyErr_Occurred()) SWIG_fail;
26429 }
26430 resultobj = SWIG_From_int((result));
26431 return resultobj;
26432 fail:
26433 return NULL;
26434 }
26435
26436
26437 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26438 PyObject *resultobj;
26439 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26440 wxString result;
26441 PyObject * obj0 = 0 ;
26442 char *kwnames[] = {
26443 (char *) "self", NULL
26444 };
26445
26446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26448 if (SWIG_arg_fail(1)) SWIG_fail;
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 result = ((wxDataFormat const *)arg1)->GetId();
26452
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 {
26457 #if wxUSE_UNICODE
26458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26459 #else
26460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26461 #endif
26462 }
26463 return resultobj;
26464 fail:
26465 return NULL;
26466 }
26467
26468
26469 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26470 PyObject *resultobj;
26471 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26472 wxString *arg2 = 0 ;
26473 bool temp2 = false ;
26474 PyObject * obj0 = 0 ;
26475 PyObject * obj1 = 0 ;
26476 char *kwnames[] = {
26477 (char *) "self",(char *) "format", NULL
26478 };
26479
26480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26482 if (SWIG_arg_fail(1)) SWIG_fail;
26483 {
26484 arg2 = wxString_in_helper(obj1);
26485 if (arg2 == NULL) SWIG_fail;
26486 temp2 = true;
26487 }
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 (arg1)->SetId((wxString const &)*arg2);
26491
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 Py_INCREF(Py_None); resultobj = Py_None;
26496 {
26497 if (temp2)
26498 delete arg2;
26499 }
26500 return resultobj;
26501 fail:
26502 {
26503 if (temp2)
26504 delete arg2;
26505 }
26506 return NULL;
26507 }
26508
26509
26510 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26511 PyObject *obj;
26512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26513 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26514 Py_INCREF(obj);
26515 return Py_BuildValue((char *)"");
26516 }
26517 static int _wrap_FormatInvalid_set(PyObject *) {
26518 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26519 return 1;
26520 }
26521
26522
26523 static PyObject *_wrap_FormatInvalid_get(void) {
26524 PyObject *pyobj;
26525
26526 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26527 return pyobj;
26528 }
26529
26530
26531 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj;
26533 wxDataObject *arg1 = (wxDataObject *) 0 ;
26534 PyObject * obj0 = 0 ;
26535 char *kwnames[] = {
26536 (char *) "self", NULL
26537 };
26538
26539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26541 if (SWIG_arg_fail(1)) SWIG_fail;
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 delete arg1;
26545
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 Py_INCREF(Py_None); resultobj = Py_None;
26550 return resultobj;
26551 fail:
26552 return NULL;
26553 }
26554
26555
26556 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26557 PyObject *resultobj;
26558 wxDataObject *arg1 = (wxDataObject *) 0 ;
26559 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26560 SwigValueWrapper<wxDataFormat > result;
26561 PyObject * obj0 = 0 ;
26562 PyObject * obj1 = 0 ;
26563 char *kwnames[] = {
26564 (char *) "self",(char *) "dir", NULL
26565 };
26566
26567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26569 if (SWIG_arg_fail(1)) SWIG_fail;
26570 if (obj1) {
26571 {
26572 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26573 if (SWIG_arg_fail(2)) SWIG_fail;
26574 }
26575 }
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26579
26580 wxPyEndAllowThreads(__tstate);
26581 if (PyErr_Occurred()) SWIG_fail;
26582 }
26583 {
26584 wxDataFormat * resultptr;
26585 resultptr = new wxDataFormat((wxDataFormat &)(result));
26586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26587 }
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26595 PyObject *resultobj;
26596 wxDataObject *arg1 = (wxDataObject *) 0 ;
26597 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26598 size_t result;
26599 PyObject * obj0 = 0 ;
26600 PyObject * obj1 = 0 ;
26601 char *kwnames[] = {
26602 (char *) "self",(char *) "dir", NULL
26603 };
26604
26605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26607 if (SWIG_arg_fail(1)) SWIG_fail;
26608 if (obj1) {
26609 {
26610 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26611 if (SWIG_arg_fail(2)) SWIG_fail;
26612 }
26613 }
26614 {
26615 PyThreadState* __tstate = wxPyBeginAllowThreads();
26616 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26617
26618 wxPyEndAllowThreads(__tstate);
26619 if (PyErr_Occurred()) SWIG_fail;
26620 }
26621 {
26622 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26623 }
26624 return resultobj;
26625 fail:
26626 return NULL;
26627 }
26628
26629
26630 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26631 PyObject *resultobj;
26632 wxDataObject *arg1 = (wxDataObject *) 0 ;
26633 wxDataFormat *arg2 = 0 ;
26634 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26635 bool result;
26636 PyObject * obj0 = 0 ;
26637 PyObject * obj1 = 0 ;
26638 PyObject * obj2 = 0 ;
26639 char *kwnames[] = {
26640 (char *) "self",(char *) "format",(char *) "dir", NULL
26641 };
26642
26643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26645 if (SWIG_arg_fail(1)) SWIG_fail;
26646 {
26647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26648 if (SWIG_arg_fail(2)) SWIG_fail;
26649 if (arg2 == NULL) {
26650 SWIG_null_ref("wxDataFormat");
26651 }
26652 if (SWIG_arg_fail(2)) SWIG_fail;
26653 }
26654 if (obj2) {
26655 {
26656 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26657 if (SWIG_arg_fail(3)) SWIG_fail;
26658 }
26659 }
26660 {
26661 PyThreadState* __tstate = wxPyBeginAllowThreads();
26662 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26663
26664 wxPyEndAllowThreads(__tstate);
26665 if (PyErr_Occurred()) SWIG_fail;
26666 }
26667 {
26668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26669 }
26670 return resultobj;
26671 fail:
26672 return NULL;
26673 }
26674
26675
26676 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26677 PyObject *resultobj;
26678 wxDataObject *arg1 = (wxDataObject *) 0 ;
26679 wxDataFormat *arg2 = 0 ;
26680 size_t result;
26681 PyObject * obj0 = 0 ;
26682 PyObject * obj1 = 0 ;
26683 char *kwnames[] = {
26684 (char *) "self",(char *) "format", NULL
26685 };
26686
26687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26689 if (SWIG_arg_fail(1)) SWIG_fail;
26690 {
26691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26692 if (SWIG_arg_fail(2)) SWIG_fail;
26693 if (arg2 == NULL) {
26694 SWIG_null_ref("wxDataFormat");
26695 }
26696 if (SWIG_arg_fail(2)) SWIG_fail;
26697 }
26698 {
26699 PyThreadState* __tstate = wxPyBeginAllowThreads();
26700 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26701
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 {
26706 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26707 }
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26715 PyObject *resultobj;
26716 wxDataObject *arg1 = (wxDataObject *) 0 ;
26717 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26718 PyObject *result;
26719 PyObject * obj0 = 0 ;
26720 PyObject * obj1 = 0 ;
26721 char *kwnames[] = {
26722 (char *) "self",(char *) "dir", NULL
26723 };
26724
26725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26727 if (SWIG_arg_fail(1)) SWIG_fail;
26728 if (obj1) {
26729 {
26730 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26731 if (SWIG_arg_fail(2)) SWIG_fail;
26732 }
26733 }
26734 {
26735 PyThreadState* __tstate = wxPyBeginAllowThreads();
26736 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26737
26738 wxPyEndAllowThreads(__tstate);
26739 if (PyErr_Occurred()) SWIG_fail;
26740 }
26741 resultobj = result;
26742 return resultobj;
26743 fail:
26744 return NULL;
26745 }
26746
26747
26748 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26749 PyObject *resultobj;
26750 wxDataObject *arg1 = (wxDataObject *) 0 ;
26751 wxDataFormat *arg2 = 0 ;
26752 PyObject *result;
26753 PyObject * obj0 = 0 ;
26754 PyObject * obj1 = 0 ;
26755 char *kwnames[] = {
26756 (char *) "self",(char *) "format", NULL
26757 };
26758
26759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26761 if (SWIG_arg_fail(1)) SWIG_fail;
26762 {
26763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26764 if (SWIG_arg_fail(2)) SWIG_fail;
26765 if (arg2 == NULL) {
26766 SWIG_null_ref("wxDataFormat");
26767 }
26768 if (SWIG_arg_fail(2)) SWIG_fail;
26769 }
26770 {
26771 PyThreadState* __tstate = wxPyBeginAllowThreads();
26772 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26773
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 resultobj = result;
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj;
26786 wxDataObject *arg1 = (wxDataObject *) 0 ;
26787 wxDataFormat *arg2 = 0 ;
26788 PyObject *arg3 = (PyObject *) 0 ;
26789 bool result;
26790 PyObject * obj0 = 0 ;
26791 PyObject * obj1 = 0 ;
26792 PyObject * obj2 = 0 ;
26793 char *kwnames[] = {
26794 (char *) "self",(char *) "format",(char *) "data", NULL
26795 };
26796
26797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26799 if (SWIG_arg_fail(1)) SWIG_fail;
26800 {
26801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26802 if (SWIG_arg_fail(2)) SWIG_fail;
26803 if (arg2 == NULL) {
26804 SWIG_null_ref("wxDataFormat");
26805 }
26806 if (SWIG_arg_fail(2)) SWIG_fail;
26807 }
26808 arg3 = obj2;
26809 {
26810 PyThreadState* __tstate = wxPyBeginAllowThreads();
26811 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26812
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 {
26817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26818 }
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26826 PyObject *obj;
26827 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26828 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26829 Py_INCREF(obj);
26830 return Py_BuildValue((char *)"");
26831 }
26832 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26833 PyObject *resultobj;
26834 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26835 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26836 wxDataObjectSimple *result;
26837 PyObject * obj0 = 0 ;
26838 char *kwnames[] = {
26839 (char *) "format", NULL
26840 };
26841
26842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26843 if (obj0) {
26844 {
26845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26846 if (SWIG_arg_fail(1)) SWIG_fail;
26847 if (arg1 == NULL) {
26848 SWIG_null_ref("wxDataFormat");
26849 }
26850 if (SWIG_arg_fail(1)) SWIG_fail;
26851 }
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26856
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26868 PyObject *resultobj;
26869 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26870 wxDataFormat *result;
26871 PyObject * obj0 = 0 ;
26872 char *kwnames[] = {
26873 (char *) "self", NULL
26874 };
26875
26876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
26877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26878 if (SWIG_arg_fail(1)) SWIG_fail;
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 {
26882 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26883 result = (wxDataFormat *) &_result_ref;
26884 }
26885
26886 wxPyEndAllowThreads(__tstate);
26887 if (PyErr_Occurred()) SWIG_fail;
26888 }
26889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj;
26898 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26899 wxDataFormat *arg2 = 0 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 char *kwnames[] = {
26903 (char *) "self",(char *) "format", NULL
26904 };
26905
26906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26908 if (SWIG_arg_fail(1)) SWIG_fail;
26909 {
26910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26911 if (SWIG_arg_fail(2)) SWIG_fail;
26912 if (arg2 == NULL) {
26913 SWIG_null_ref("wxDataFormat");
26914 }
26915 if (SWIG_arg_fail(2)) SWIG_fail;
26916 }
26917 {
26918 PyThreadState* __tstate = wxPyBeginAllowThreads();
26919 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26920
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 Py_INCREF(Py_None); resultobj = Py_None;
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26932 PyObject *resultobj;
26933 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26934 size_t result;
26935 PyObject * obj0 = 0 ;
26936 char *kwnames[] = {
26937 (char *) "self", NULL
26938 };
26939
26940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26942 if (SWIG_arg_fail(1)) SWIG_fail;
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26946
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 {
26951 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26952 }
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj;
26961 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26962 PyObject *result;
26963 PyObject * obj0 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
26974
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 resultobj = result;
26979 return resultobj;
26980 fail:
26981 return NULL;
26982 }
26983
26984
26985 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26986 PyObject *resultobj;
26987 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26988 PyObject *arg2 = (PyObject *) 0 ;
26989 bool result;
26990 PyObject * obj0 = 0 ;
26991 PyObject * obj1 = 0 ;
26992 char *kwnames[] = {
26993 (char *) "self",(char *) "data", NULL
26994 };
26995
26996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
26997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26998 if (SWIG_arg_fail(1)) SWIG_fail;
26999 arg2 = obj1;
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27003
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 {
27008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27009 }
27010 return resultobj;
27011 fail:
27012 return NULL;
27013 }
27014
27015
27016 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27017 PyObject *obj;
27018 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27019 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27020 Py_INCREF(obj);
27021 return Py_BuildValue((char *)"");
27022 }
27023 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27024 PyObject *resultobj;
27025 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27026 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27027 wxPyDataObjectSimple *result;
27028 PyObject * obj0 = 0 ;
27029 char *kwnames[] = {
27030 (char *) "format", NULL
27031 };
27032
27033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27034 if (obj0) {
27035 {
27036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27037 if (SWIG_arg_fail(1)) SWIG_fail;
27038 if (arg1 == NULL) {
27039 SWIG_null_ref("wxDataFormat");
27040 }
27041 if (SWIG_arg_fail(1)) SWIG_fail;
27042 }
27043 }
27044 {
27045 PyThreadState* __tstate = wxPyBeginAllowThreads();
27046 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27047
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27059 PyObject *resultobj;
27060 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27061 PyObject *arg2 = (PyObject *) 0 ;
27062 PyObject *arg3 = (PyObject *) 0 ;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 PyObject * obj2 = 0 ;
27066 char *kwnames[] = {
27067 (char *) "self",(char *) "self",(char *) "_class", NULL
27068 };
27069
27070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27072 if (SWIG_arg_fail(1)) SWIG_fail;
27073 arg2 = obj1;
27074 arg3 = obj2;
27075 {
27076 PyThreadState* __tstate = wxPyBeginAllowThreads();
27077 (arg1)->_setCallbackInfo(arg2,arg3);
27078
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 Py_INCREF(Py_None); resultobj = Py_None;
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27090 PyObject *obj;
27091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27092 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27093 Py_INCREF(obj);
27094 return Py_BuildValue((char *)"");
27095 }
27096 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxDataObjectComposite *result;
27099 char *kwnames[] = {
27100 NULL
27101 };
27102
27103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27104 {
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27107
27108 wxPyEndAllowThreads(__tstate);
27109 if (PyErr_Occurred()) SWIG_fail;
27110 }
27111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27112 return resultobj;
27113 fail:
27114 return NULL;
27115 }
27116
27117
27118 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27119 PyObject *resultobj;
27120 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27121 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27122 bool arg3 = (bool) false ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 PyObject * obj2 = 0 ;
27126 char *kwnames[] = {
27127 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27128 };
27129
27130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27132 if (SWIG_arg_fail(1)) SWIG_fail;
27133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27134 if (SWIG_arg_fail(2)) SWIG_fail;
27135 if (obj2) {
27136 {
27137 arg3 = (bool)(SWIG_As_bool(obj2));
27138 if (SWIG_arg_fail(3)) SWIG_fail;
27139 }
27140 }
27141 {
27142 PyThreadState* __tstate = wxPyBeginAllowThreads();
27143 (arg1)->Add(arg2,arg3);
27144
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 Py_INCREF(Py_None); resultobj = Py_None;
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27156 PyObject *obj;
27157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27158 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27159 Py_INCREF(obj);
27160 return Py_BuildValue((char *)"");
27161 }
27162 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27163 PyObject *resultobj;
27164 wxString const &arg1_defvalue = wxPyEmptyString ;
27165 wxString *arg1 = (wxString *) &arg1_defvalue ;
27166 wxTextDataObject *result;
27167 bool temp1 = false ;
27168 PyObject * obj0 = 0 ;
27169 char *kwnames[] = {
27170 (char *) "text", NULL
27171 };
27172
27173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27174 if (obj0) {
27175 {
27176 arg1 = wxString_in_helper(obj0);
27177 if (arg1 == NULL) SWIG_fail;
27178 temp1 = true;
27179 }
27180 }
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27184
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27189 {
27190 if (temp1)
27191 delete arg1;
27192 }
27193 return resultobj;
27194 fail:
27195 {
27196 if (temp1)
27197 delete arg1;
27198 }
27199 return NULL;
27200 }
27201
27202
27203 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27204 PyObject *resultobj;
27205 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27206 size_t result;
27207 PyObject * obj0 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27214 if (SWIG_arg_fail(1)) SWIG_fail;
27215 {
27216 PyThreadState* __tstate = wxPyBeginAllowThreads();
27217 result = (size_t)(arg1)->GetTextLength();
27218
27219 wxPyEndAllowThreads(__tstate);
27220 if (PyErr_Occurred()) SWIG_fail;
27221 }
27222 {
27223 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27224 }
27225 return resultobj;
27226 fail:
27227 return NULL;
27228 }
27229
27230
27231 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27232 PyObject *resultobj;
27233 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27234 wxString result;
27235 PyObject * obj0 = 0 ;
27236 char *kwnames[] = {
27237 (char *) "self", NULL
27238 };
27239
27240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27242 if (SWIG_arg_fail(1)) SWIG_fail;
27243 {
27244 PyThreadState* __tstate = wxPyBeginAllowThreads();
27245 result = (arg1)->GetText();
27246
27247 wxPyEndAllowThreads(__tstate);
27248 if (PyErr_Occurred()) SWIG_fail;
27249 }
27250 {
27251 #if wxUSE_UNICODE
27252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27253 #else
27254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27255 #endif
27256 }
27257 return resultobj;
27258 fail:
27259 return NULL;
27260 }
27261
27262
27263 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27264 PyObject *resultobj;
27265 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27266 wxString *arg2 = 0 ;
27267 bool temp2 = false ;
27268 PyObject * obj0 = 0 ;
27269 PyObject * obj1 = 0 ;
27270 char *kwnames[] = {
27271 (char *) "self",(char *) "text", NULL
27272 };
27273
27274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 {
27278 arg2 = wxString_in_helper(obj1);
27279 if (arg2 == NULL) SWIG_fail;
27280 temp2 = true;
27281 }
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 (arg1)->SetText((wxString const &)*arg2);
27285
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 Py_INCREF(Py_None); resultobj = Py_None;
27290 {
27291 if (temp2)
27292 delete arg2;
27293 }
27294 return resultobj;
27295 fail:
27296 {
27297 if (temp2)
27298 delete arg2;
27299 }
27300 return NULL;
27301 }
27302
27303
27304 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27305 PyObject *obj;
27306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27307 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27308 Py_INCREF(obj);
27309 return Py_BuildValue((char *)"");
27310 }
27311 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27312 PyObject *resultobj;
27313 wxString const &arg1_defvalue = wxPyEmptyString ;
27314 wxString *arg1 = (wxString *) &arg1_defvalue ;
27315 wxPyTextDataObject *result;
27316 bool temp1 = false ;
27317 PyObject * obj0 = 0 ;
27318 char *kwnames[] = {
27319 (char *) "text", NULL
27320 };
27321
27322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27323 if (obj0) {
27324 {
27325 arg1 = wxString_in_helper(obj0);
27326 if (arg1 == NULL) SWIG_fail;
27327 temp1 = true;
27328 }
27329 }
27330 {
27331 PyThreadState* __tstate = wxPyBeginAllowThreads();
27332 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27333
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27338 {
27339 if (temp1)
27340 delete arg1;
27341 }
27342 return resultobj;
27343 fail:
27344 {
27345 if (temp1)
27346 delete arg1;
27347 }
27348 return NULL;
27349 }
27350
27351
27352 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj;
27354 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27355 PyObject *arg2 = (PyObject *) 0 ;
27356 PyObject *arg3 = (PyObject *) 0 ;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 PyObject * obj2 = 0 ;
27360 char *kwnames[] = {
27361 (char *) "self",(char *) "self",(char *) "_class", NULL
27362 };
27363
27364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27366 if (SWIG_arg_fail(1)) SWIG_fail;
27367 arg2 = obj1;
27368 arg3 = obj2;
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 (arg1)->_setCallbackInfo(arg2,arg3);
27372
27373 wxPyEndAllowThreads(__tstate);
27374 if (PyErr_Occurred()) SWIG_fail;
27375 }
27376 Py_INCREF(Py_None); resultobj = Py_None;
27377 return resultobj;
27378 fail:
27379 return NULL;
27380 }
27381
27382
27383 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27384 PyObject *obj;
27385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27386 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27387 Py_INCREF(obj);
27388 return Py_BuildValue((char *)"");
27389 }
27390 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj;
27392 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27393 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27394 wxBitmapDataObject *result;
27395 PyObject * obj0 = 0 ;
27396 char *kwnames[] = {
27397 (char *) "bitmap", NULL
27398 };
27399
27400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27401 if (obj0) {
27402 {
27403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27404 if (SWIG_arg_fail(1)) SWIG_fail;
27405 if (arg1 == NULL) {
27406 SWIG_null_ref("wxBitmap");
27407 }
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 }
27410 }
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27414
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27419 return resultobj;
27420 fail:
27421 return NULL;
27422 }
27423
27424
27425 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27426 PyObject *resultobj;
27427 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27428 wxBitmap result;
27429 PyObject * obj0 = 0 ;
27430 char *kwnames[] = {
27431 (char *) "self", NULL
27432 };
27433
27434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27436 if (SWIG_arg_fail(1)) SWIG_fail;
27437 {
27438 PyThreadState* __tstate = wxPyBeginAllowThreads();
27439 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27440
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 {
27445 wxBitmap * resultptr;
27446 resultptr = new wxBitmap((wxBitmap &)(result));
27447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27448 }
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27456 PyObject *resultobj;
27457 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27458 wxBitmap *arg2 = 0 ;
27459 PyObject * obj0 = 0 ;
27460 PyObject * obj1 = 0 ;
27461 char *kwnames[] = {
27462 (char *) "self",(char *) "bitmap", NULL
27463 };
27464
27465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27467 if (SWIG_arg_fail(1)) SWIG_fail;
27468 {
27469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27470 if (SWIG_arg_fail(2)) SWIG_fail;
27471 if (arg2 == NULL) {
27472 SWIG_null_ref("wxBitmap");
27473 }
27474 if (SWIG_arg_fail(2)) SWIG_fail;
27475 }
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27479
27480 wxPyEndAllowThreads(__tstate);
27481 if (PyErr_Occurred()) SWIG_fail;
27482 }
27483 Py_INCREF(Py_None); resultobj = Py_None;
27484 return resultobj;
27485 fail:
27486 return NULL;
27487 }
27488
27489
27490 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27491 PyObject *obj;
27492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27493 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27494 Py_INCREF(obj);
27495 return Py_BuildValue((char *)"");
27496 }
27497 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj;
27499 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27500 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27501 wxPyBitmapDataObject *result;
27502 PyObject * obj0 = 0 ;
27503 char *kwnames[] = {
27504 (char *) "bitmap", NULL
27505 };
27506
27507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27508 if (obj0) {
27509 {
27510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27511 if (SWIG_arg_fail(1)) SWIG_fail;
27512 if (arg1 == NULL) {
27513 SWIG_null_ref("wxBitmap");
27514 }
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 }
27517 }
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj;
27534 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27535 PyObject *arg2 = (PyObject *) 0 ;
27536 PyObject *arg3 = (PyObject *) 0 ;
27537 PyObject * obj0 = 0 ;
27538 PyObject * obj1 = 0 ;
27539 PyObject * obj2 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "self",(char *) "_class", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 arg2 = obj1;
27548 arg3 = obj2;
27549 {
27550 PyThreadState* __tstate = wxPyBeginAllowThreads();
27551 (arg1)->_setCallbackInfo(arg2,arg3);
27552
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 Py_INCREF(Py_None); resultobj = Py_None;
27557 return resultobj;
27558 fail:
27559 return NULL;
27560 }
27561
27562
27563 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27564 PyObject *obj;
27565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27566 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27567 Py_INCREF(obj);
27568 return Py_BuildValue((char *)"");
27569 }
27570 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27571 PyObject *resultobj;
27572 wxFileDataObject *result;
27573 char *kwnames[] = {
27574 NULL
27575 };
27576
27577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = (wxFileDataObject *)new wxFileDataObject();
27581
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27593 PyObject *resultobj;
27594 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27595 wxArrayString *result;
27596 PyObject * obj0 = 0 ;
27597 char *kwnames[] = {
27598 (char *) "self", NULL
27599 };
27600
27601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27603 if (SWIG_arg_fail(1)) SWIG_fail;
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 {
27607 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27608 result = (wxArrayString *) &_result_ref;
27609 }
27610
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 {
27615 resultobj = wxArrayString2PyList_helper(*result);
27616 }
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27624 PyObject *resultobj;
27625 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27626 wxString *arg2 = 0 ;
27627 bool temp2 = false ;
27628 PyObject * obj0 = 0 ;
27629 PyObject * obj1 = 0 ;
27630 char *kwnames[] = {
27631 (char *) "self",(char *) "filename", NULL
27632 };
27633
27634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27636 if (SWIG_arg_fail(1)) SWIG_fail;
27637 {
27638 arg2 = wxString_in_helper(obj1);
27639 if (arg2 == NULL) SWIG_fail;
27640 temp2 = true;
27641 }
27642 {
27643 PyThreadState* __tstate = wxPyBeginAllowThreads();
27644 (arg1)->AddFile((wxString const &)*arg2);
27645
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 Py_INCREF(Py_None); resultobj = Py_None;
27650 {
27651 if (temp2)
27652 delete arg2;
27653 }
27654 return resultobj;
27655 fail:
27656 {
27657 if (temp2)
27658 delete arg2;
27659 }
27660 return NULL;
27661 }
27662
27663
27664 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27665 PyObject *obj;
27666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27667 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27668 Py_INCREF(obj);
27669 return Py_BuildValue((char *)"");
27670 }
27671 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27672 PyObject *resultobj;
27673 wxDataFormat *arg1 = 0 ;
27674 wxCustomDataObject *result;
27675 PyObject * obj0 = 0 ;
27676
27677 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27678 {
27679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27680 if (SWIG_arg_fail(1)) SWIG_fail;
27681 if (arg1 == NULL) {
27682 SWIG_null_ref("wxDataFormat");
27683 }
27684 if (SWIG_arg_fail(1)) SWIG_fail;
27685 }
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27689
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27694 return resultobj;
27695 fail:
27696 return NULL;
27697 }
27698
27699
27700 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27701 PyObject *resultobj;
27702 wxString *arg1 = 0 ;
27703 wxCustomDataObject *result;
27704 bool temp1 = false ;
27705 PyObject * obj0 = 0 ;
27706
27707 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27708 {
27709 arg1 = wxString_in_helper(obj0);
27710 if (arg1 == NULL) SWIG_fail;
27711 temp1 = true;
27712 }
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27716
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27721 {
27722 if (temp1)
27723 delete arg1;
27724 }
27725 return resultobj;
27726 fail:
27727 {
27728 if (temp1)
27729 delete arg1;
27730 }
27731 return NULL;
27732 }
27733
27734
27735 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27736 PyObject *resultobj;
27737 wxCustomDataObject *result;
27738
27739 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27740 {
27741 PyThreadState* __tstate = wxPyBeginAllowThreads();
27742 result = (wxCustomDataObject *)new wxCustomDataObject();
27743
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27755 int argc;
27756 PyObject *argv[2];
27757 int ii;
27758
27759 argc = PyObject_Length(args);
27760 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27761 argv[ii] = PyTuple_GetItem(args,ii);
27762 }
27763 if (argc == 0) {
27764 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27765 }
27766 if (argc == 1) {
27767 int _v;
27768 {
27769 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27770 }
27771 if (_v) {
27772 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27773 }
27774 }
27775 if (argc == 1) {
27776 int _v;
27777 {
27778 void *ptr = 0;
27779 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27780 _v = 0;
27781 PyErr_Clear();
27782 } else {
27783 _v = (ptr != 0);
27784 }
27785 }
27786 if (_v) {
27787 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27788 }
27789 }
27790
27791 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27792 return NULL;
27793 }
27794
27795
27796 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27797 PyObject *resultobj;
27798 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27799 PyObject *arg2 = (PyObject *) 0 ;
27800 bool result;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 char *kwnames[] = {
27804 (char *) "self",(char *) "data", NULL
27805 };
27806
27807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27809 if (SWIG_arg_fail(1)) SWIG_fail;
27810 arg2 = obj1;
27811 {
27812 PyThreadState* __tstate = wxPyBeginAllowThreads();
27813 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27814
27815 wxPyEndAllowThreads(__tstate);
27816 if (PyErr_Occurred()) SWIG_fail;
27817 }
27818 {
27819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27820 }
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27828 PyObject *resultobj;
27829 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27830 size_t result;
27831 PyObject * obj0 = 0 ;
27832 char *kwnames[] = {
27833 (char *) "self", NULL
27834 };
27835
27836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27838 if (SWIG_arg_fail(1)) SWIG_fail;
27839 {
27840 PyThreadState* __tstate = wxPyBeginAllowThreads();
27841 result = (size_t)(arg1)->GetSize();
27842
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 {
27847 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27848 }
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj;
27857 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27858 PyObject *result;
27859 PyObject * obj0 = 0 ;
27860 char *kwnames[] = {
27861 (char *) "self", NULL
27862 };
27863
27864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27866 if (SWIG_arg_fail(1)) SWIG_fail;
27867 {
27868 PyThreadState* __tstate = wxPyBeginAllowThreads();
27869 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27870
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 resultobj = result;
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27882 PyObject *obj;
27883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27884 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27885 Py_INCREF(obj);
27886 return Py_BuildValue((char *)"");
27887 }
27888 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj;
27890 wxURLDataObject *result;
27891 char *kwnames[] = {
27892 NULL
27893 };
27894
27895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (wxURLDataObject *)new wxURLDataObject();
27899
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27904 return resultobj;
27905 fail:
27906 return NULL;
27907 }
27908
27909
27910 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj;
27912 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27913 wxString result;
27914 PyObject * obj0 = 0 ;
27915 char *kwnames[] = {
27916 (char *) "self", NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (arg1)->GetURL();
27925
27926 wxPyEndAllowThreads(__tstate);
27927 if (PyErr_Occurred()) SWIG_fail;
27928 }
27929 {
27930 #if wxUSE_UNICODE
27931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27932 #else
27933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27934 #endif
27935 }
27936 return resultobj;
27937 fail:
27938 return NULL;
27939 }
27940
27941
27942 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27943 PyObject *resultobj;
27944 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27945 wxString *arg2 = 0 ;
27946 bool temp2 = false ;
27947 PyObject * obj0 = 0 ;
27948 PyObject * obj1 = 0 ;
27949 char *kwnames[] = {
27950 (char *) "self",(char *) "url", NULL
27951 };
27952
27953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27955 if (SWIG_arg_fail(1)) SWIG_fail;
27956 {
27957 arg2 = wxString_in_helper(obj1);
27958 if (arg2 == NULL) SWIG_fail;
27959 temp2 = true;
27960 }
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 (arg1)->SetURL((wxString const &)*arg2);
27964
27965 wxPyEndAllowThreads(__tstate);
27966 if (PyErr_Occurred()) SWIG_fail;
27967 }
27968 Py_INCREF(Py_None); resultobj = Py_None;
27969 {
27970 if (temp2)
27971 delete arg2;
27972 }
27973 return resultobj;
27974 fail:
27975 {
27976 if (temp2)
27977 delete arg2;
27978 }
27979 return NULL;
27980 }
27981
27982
27983 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
27984 PyObject *obj;
27985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27986 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
27987 Py_INCREF(obj);
27988 return Py_BuildValue((char *)"");
27989 }
27990 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27991 PyObject *resultobj;
27992 wxMetafileDataObject *result;
27993 char *kwnames[] = {
27994 NULL
27995 };
27996
27997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28001
28002 wxPyEndAllowThreads(__tstate);
28003 if (PyErr_Occurred()) SWIG_fail;
28004 }
28005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28006 return resultobj;
28007 fail:
28008 return NULL;
28009 }
28010
28011
28012 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28013 PyObject *obj;
28014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28015 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28016 Py_INCREF(obj);
28017 return Py_BuildValue((char *)"");
28018 }
28019 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28020 PyObject *resultobj;
28021 wxDragResult arg1 ;
28022 bool result;
28023 PyObject * obj0 = 0 ;
28024 char *kwnames[] = {
28025 (char *) "res", NULL
28026 };
28027
28028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28029 {
28030 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28031 if (SWIG_arg_fail(1)) SWIG_fail;
28032 }
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28036
28037 wxPyEndAllowThreads(__tstate);
28038 if (PyErr_Occurred()) SWIG_fail;
28039 }
28040 {
28041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28042 }
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj;
28051 wxWindow *arg1 = (wxWindow *) 0 ;
28052 wxIcon const &arg2_defvalue = wxNullIcon ;
28053 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28054 wxIcon const &arg3_defvalue = wxNullIcon ;
28055 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28056 wxIcon const &arg4_defvalue = wxNullIcon ;
28057 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28058 wxPyDropSource *result;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 PyObject * obj2 = 0 ;
28062 PyObject * obj3 = 0 ;
28063 char *kwnames[] = {
28064 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28065 };
28066
28067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28069 if (SWIG_arg_fail(1)) SWIG_fail;
28070 if (obj1) {
28071 {
28072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28073 if (SWIG_arg_fail(2)) SWIG_fail;
28074 if (arg2 == NULL) {
28075 SWIG_null_ref("wxIcon");
28076 }
28077 if (SWIG_arg_fail(2)) SWIG_fail;
28078 }
28079 }
28080 if (obj2) {
28081 {
28082 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28083 if (SWIG_arg_fail(3)) SWIG_fail;
28084 if (arg3 == NULL) {
28085 SWIG_null_ref("wxIcon");
28086 }
28087 if (SWIG_arg_fail(3)) SWIG_fail;
28088 }
28089 }
28090 if (obj3) {
28091 {
28092 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28093 if (SWIG_arg_fail(4)) SWIG_fail;
28094 if (arg4 == NULL) {
28095 SWIG_null_ref("wxIcon");
28096 }
28097 if (SWIG_arg_fail(4)) SWIG_fail;
28098 }
28099 }
28100 {
28101 PyThreadState* __tstate = wxPyBeginAllowThreads();
28102 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28103
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj;
28116 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28117 PyObject *arg2 = (PyObject *) 0 ;
28118 PyObject *arg3 = (PyObject *) 0 ;
28119 int arg4 ;
28120 PyObject * obj0 = 0 ;
28121 PyObject * obj1 = 0 ;
28122 PyObject * obj2 = 0 ;
28123 PyObject * obj3 = 0 ;
28124 char *kwnames[] = {
28125 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28126 };
28127
28128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28130 if (SWIG_arg_fail(1)) SWIG_fail;
28131 arg2 = obj1;
28132 arg3 = obj2;
28133 {
28134 arg4 = (int)(SWIG_As_int(obj3));
28135 if (SWIG_arg_fail(4)) SWIG_fail;
28136 }
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28140
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 Py_INCREF(Py_None); resultobj = Py_None;
28145 return resultobj;
28146 fail:
28147 return NULL;
28148 }
28149
28150
28151 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28152 PyObject *resultobj;
28153 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28154 PyObject * obj0 = 0 ;
28155 char *kwnames[] = {
28156 (char *) "self", NULL
28157 };
28158
28159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(1)) SWIG_fail;
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 delete arg1;
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 Py_INCREF(Py_None); resultobj = Py_None;
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj;
28178 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28179 wxDataObject *arg2 = 0 ;
28180 PyObject * obj0 = 0 ;
28181 PyObject * obj1 = 0 ;
28182 char *kwnames[] = {
28183 (char *) "self",(char *) "data", NULL
28184 };
28185
28186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28188 if (SWIG_arg_fail(1)) SWIG_fail;
28189 {
28190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(2)) SWIG_fail;
28192 if (arg2 == NULL) {
28193 SWIG_null_ref("wxDataObject");
28194 }
28195 if (SWIG_arg_fail(2)) SWIG_fail;
28196 }
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 (arg1)->SetData(*arg2);
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 Py_INCREF(Py_None); resultobj = Py_None;
28205 return resultobj;
28206 fail:
28207 return NULL;
28208 }
28209
28210
28211 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28212 PyObject *resultobj;
28213 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28214 wxDataObject *result;
28215 PyObject * obj0 = 0 ;
28216 char *kwnames[] = {
28217 (char *) "self", NULL
28218 };
28219
28220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28222 if (SWIG_arg_fail(1)) SWIG_fail;
28223 {
28224 PyThreadState* __tstate = wxPyBeginAllowThreads();
28225 result = (wxDataObject *)(arg1)->GetDataObject();
28226
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28238 PyObject *resultobj;
28239 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28240 wxDragResult arg2 ;
28241 wxCursor *arg3 = 0 ;
28242 PyObject * obj0 = 0 ;
28243 PyObject * obj1 = 0 ;
28244 PyObject * obj2 = 0 ;
28245 char *kwnames[] = {
28246 (char *) "self",(char *) "res",(char *) "cursor", NULL
28247 };
28248
28249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28251 if (SWIG_arg_fail(1)) SWIG_fail;
28252 {
28253 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28254 if (SWIG_arg_fail(2)) SWIG_fail;
28255 }
28256 {
28257 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28258 if (SWIG_arg_fail(3)) SWIG_fail;
28259 if (arg3 == NULL) {
28260 SWIG_null_ref("wxCursor");
28261 }
28262 if (SWIG_arg_fail(3)) SWIG_fail;
28263 }
28264 {
28265 PyThreadState* __tstate = wxPyBeginAllowThreads();
28266 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28267
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 Py_INCREF(Py_None); resultobj = Py_None;
28272 return resultobj;
28273 fail:
28274 return NULL;
28275 }
28276
28277
28278 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28279 PyObject *resultobj;
28280 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28281 int arg2 = (int) wxDrag_CopyOnly ;
28282 wxDragResult result;
28283 PyObject * obj0 = 0 ;
28284 PyObject * obj1 = 0 ;
28285 char *kwnames[] = {
28286 (char *) "self",(char *) "flags", NULL
28287 };
28288
28289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28291 if (SWIG_arg_fail(1)) SWIG_fail;
28292 if (obj1) {
28293 {
28294 arg2 = (int)(SWIG_As_int(obj1));
28295 if (SWIG_arg_fail(2)) SWIG_fail;
28296 }
28297 }
28298 {
28299 PyThreadState* __tstate = wxPyBeginAllowThreads();
28300 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28301
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 resultobj = SWIG_From_int((result));
28306 return resultobj;
28307 fail:
28308 return NULL;
28309 }
28310
28311
28312 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28313 PyObject *resultobj;
28314 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28315 wxDragResult arg2 ;
28316 bool result;
28317 PyObject * obj0 = 0 ;
28318 PyObject * obj1 = 0 ;
28319 char *kwnames[] = {
28320 (char *) "self",(char *) "effect", NULL
28321 };
28322
28323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28325 if (SWIG_arg_fail(1)) SWIG_fail;
28326 {
28327 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28328 if (SWIG_arg_fail(2)) SWIG_fail;
28329 }
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28333
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 {
28338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28339 }
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28347 PyObject *obj;
28348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28349 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28350 Py_INCREF(obj);
28351 return Py_BuildValue((char *)"");
28352 }
28353 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28354 PyObject *resultobj;
28355 wxDataObject *arg1 = (wxDataObject *) NULL ;
28356 wxPyDropTarget *result;
28357 PyObject * obj0 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "dataObject", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28363 if (obj0) {
28364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28365 if (SWIG_arg_fail(1)) SWIG_fail;
28366 }
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28370
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj;
28383 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28384 PyObject *arg2 = (PyObject *) 0 ;
28385 PyObject *arg3 = (PyObject *) 0 ;
28386 PyObject * obj0 = 0 ;
28387 PyObject * obj1 = 0 ;
28388 PyObject * obj2 = 0 ;
28389 char *kwnames[] = {
28390 (char *) "self",(char *) "self",(char *) "_class", NULL
28391 };
28392
28393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28395 if (SWIG_arg_fail(1)) SWIG_fail;
28396 arg2 = obj1;
28397 arg3 = obj2;
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 (arg1)->_setCallbackInfo(arg2,arg3);
28401
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 Py_INCREF(Py_None); resultobj = Py_None;
28406 return resultobj;
28407 fail:
28408 return NULL;
28409 }
28410
28411
28412 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28413 PyObject *resultobj;
28414 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28415 PyObject * obj0 = 0 ;
28416 char *kwnames[] = {
28417 (char *) "self", NULL
28418 };
28419
28420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28422 if (SWIG_arg_fail(1)) SWIG_fail;
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 delete arg1;
28426
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 Py_INCREF(Py_None); resultobj = Py_None;
28431 return resultobj;
28432 fail:
28433 return NULL;
28434 }
28435
28436
28437 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28438 PyObject *resultobj;
28439 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28440 wxDataObject *result;
28441 PyObject * obj0 = 0 ;
28442 char *kwnames[] = {
28443 (char *) "self", NULL
28444 };
28445
28446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28448 if (SWIG_arg_fail(1)) SWIG_fail;
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 result = (wxDataObject *)(arg1)->GetDataObject();
28452
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj;
28465 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28466 wxDataObject *arg2 = (wxDataObject *) 0 ;
28467 PyObject * obj0 = 0 ;
28468 PyObject * obj1 = 0 ;
28469 char *kwnames[] = {
28470 (char *) "self",(char *) "dataObject", NULL
28471 };
28472
28473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28475 if (SWIG_arg_fail(1)) SWIG_fail;
28476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28477 if (SWIG_arg_fail(2)) SWIG_fail;
28478 {
28479 PyThreadState* __tstate = wxPyBeginAllowThreads();
28480 (arg1)->SetDataObject(arg2);
28481
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 Py_INCREF(Py_None); resultobj = Py_None;
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28493 PyObject *resultobj;
28494 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28495 int arg2 ;
28496 int arg3 ;
28497 wxDragResult arg4 ;
28498 wxDragResult result;
28499 PyObject * obj0 = 0 ;
28500 PyObject * obj1 = 0 ;
28501 PyObject * obj2 = 0 ;
28502 PyObject * obj3 = 0 ;
28503 char *kwnames[] = {
28504 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28505 };
28506
28507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
28512 if (SWIG_arg_fail(2)) SWIG_fail;
28513 }
28514 {
28515 arg3 = (int)(SWIG_As_int(obj2));
28516 if (SWIG_arg_fail(3)) SWIG_fail;
28517 }
28518 {
28519 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28520 if (SWIG_arg_fail(4)) SWIG_fail;
28521 }
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28525
28526 wxPyEndAllowThreads(__tstate);
28527 if (PyErr_Occurred()) SWIG_fail;
28528 }
28529 resultobj = SWIG_From_int((result));
28530 return resultobj;
28531 fail:
28532 return NULL;
28533 }
28534
28535
28536 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28537 PyObject *resultobj;
28538 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28539 int arg2 ;
28540 int arg3 ;
28541 wxDragResult arg4 ;
28542 wxDragResult result;
28543 PyObject * obj0 = 0 ;
28544 PyObject * obj1 = 0 ;
28545 PyObject * obj2 = 0 ;
28546 PyObject * obj3 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 {
28555 arg2 = (int)(SWIG_As_int(obj1));
28556 if (SWIG_arg_fail(2)) SWIG_fail;
28557 }
28558 {
28559 arg3 = (int)(SWIG_As_int(obj2));
28560 if (SWIG_arg_fail(3)) SWIG_fail;
28561 }
28562 {
28563 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28564 if (SWIG_arg_fail(4)) SWIG_fail;
28565 }
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28569
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 resultobj = SWIG_From_int((result));
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj;
28582 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28583 PyObject * obj0 = 0 ;
28584 char *kwnames[] = {
28585 (char *) "self", NULL
28586 };
28587
28588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28590 if (SWIG_arg_fail(1)) SWIG_fail;
28591 {
28592 PyThreadState* __tstate = wxPyBeginAllowThreads();
28593 (arg1)->base_OnLeave();
28594
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 Py_INCREF(Py_None); resultobj = Py_None;
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28606 PyObject *resultobj;
28607 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28608 int arg2 ;
28609 int arg3 ;
28610 bool result;
28611 PyObject * obj0 = 0 ;
28612 PyObject * obj1 = 0 ;
28613 PyObject * obj2 = 0 ;
28614 char *kwnames[] = {
28615 (char *) "self",(char *) "x",(char *) "y", NULL
28616 };
28617
28618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28620 if (SWIG_arg_fail(1)) SWIG_fail;
28621 {
28622 arg2 = (int)(SWIG_As_int(obj1));
28623 if (SWIG_arg_fail(2)) SWIG_fail;
28624 }
28625 {
28626 arg3 = (int)(SWIG_As_int(obj2));
28627 if (SWIG_arg_fail(3)) SWIG_fail;
28628 }
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28632
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 {
28637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28638 }
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28646 PyObject *resultobj;
28647 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28648 bool result;
28649 PyObject * obj0 = 0 ;
28650 char *kwnames[] = {
28651 (char *) "self", NULL
28652 };
28653
28654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(1)) SWIG_fail;
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 result = (bool)(arg1)->GetData();
28660
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 {
28665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28666 }
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28674 PyObject *obj;
28675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28676 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28677 Py_INCREF(obj);
28678 return Py_BuildValue((char *)"");
28679 }
28680 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28681 PyObject *resultobj;
28682 wxPyTextDropTarget *result;
28683 char *kwnames[] = {
28684 NULL
28685 };
28686
28687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28691
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28703 PyObject *resultobj;
28704 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28705 PyObject *arg2 = (PyObject *) 0 ;
28706 PyObject *arg3 = (PyObject *) 0 ;
28707 PyObject * obj0 = 0 ;
28708 PyObject * obj1 = 0 ;
28709 PyObject * obj2 = 0 ;
28710 char *kwnames[] = {
28711 (char *) "self",(char *) "self",(char *) "_class", NULL
28712 };
28713
28714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 arg2 = obj1;
28718 arg3 = obj2;
28719 {
28720 PyThreadState* __tstate = wxPyBeginAllowThreads();
28721 (arg1)->_setCallbackInfo(arg2,arg3);
28722
28723 wxPyEndAllowThreads(__tstate);
28724 if (PyErr_Occurred()) SWIG_fail;
28725 }
28726 Py_INCREF(Py_None); resultobj = Py_None;
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj;
28735 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28736 int arg2 ;
28737 int arg3 ;
28738 wxDragResult arg4 ;
28739 wxDragResult result;
28740 PyObject * obj0 = 0 ;
28741 PyObject * obj1 = 0 ;
28742 PyObject * obj2 = 0 ;
28743 PyObject * obj3 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 {
28752 arg2 = (int)(SWIG_As_int(obj1));
28753 if (SWIG_arg_fail(2)) SWIG_fail;
28754 }
28755 {
28756 arg3 = (int)(SWIG_As_int(obj2));
28757 if (SWIG_arg_fail(3)) SWIG_fail;
28758 }
28759 {
28760 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28761 if (SWIG_arg_fail(4)) SWIG_fail;
28762 }
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28766
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 resultobj = SWIG_From_int((result));
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28778 PyObject *resultobj;
28779 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28780 int arg2 ;
28781 int arg3 ;
28782 wxDragResult arg4 ;
28783 wxDragResult result;
28784 PyObject * obj0 = 0 ;
28785 PyObject * obj1 = 0 ;
28786 PyObject * obj2 = 0 ;
28787 PyObject * obj3 = 0 ;
28788 char *kwnames[] = {
28789 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28790 };
28791
28792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28794 if (SWIG_arg_fail(1)) SWIG_fail;
28795 {
28796 arg2 = (int)(SWIG_As_int(obj1));
28797 if (SWIG_arg_fail(2)) SWIG_fail;
28798 }
28799 {
28800 arg3 = (int)(SWIG_As_int(obj2));
28801 if (SWIG_arg_fail(3)) SWIG_fail;
28802 }
28803 {
28804 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28805 if (SWIG_arg_fail(4)) SWIG_fail;
28806 }
28807 {
28808 PyThreadState* __tstate = wxPyBeginAllowThreads();
28809 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28810
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 resultobj = SWIG_From_int((result));
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28822 PyObject *resultobj;
28823 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28824 PyObject * obj0 = 0 ;
28825 char *kwnames[] = {
28826 (char *) "self", NULL
28827 };
28828
28829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28831 if (SWIG_arg_fail(1)) SWIG_fail;
28832 {
28833 PyThreadState* __tstate = wxPyBeginAllowThreads();
28834 (arg1)->base_OnLeave();
28835
28836 wxPyEndAllowThreads(__tstate);
28837 if (PyErr_Occurred()) SWIG_fail;
28838 }
28839 Py_INCREF(Py_None); resultobj = Py_None;
28840 return resultobj;
28841 fail:
28842 return NULL;
28843 }
28844
28845
28846 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28847 PyObject *resultobj;
28848 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28849 int arg2 ;
28850 int arg3 ;
28851 bool result;
28852 PyObject * obj0 = 0 ;
28853 PyObject * obj1 = 0 ;
28854 PyObject * obj2 = 0 ;
28855 char *kwnames[] = {
28856 (char *) "self",(char *) "x",(char *) "y", NULL
28857 };
28858
28859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28861 if (SWIG_arg_fail(1)) SWIG_fail;
28862 {
28863 arg2 = (int)(SWIG_As_int(obj1));
28864 if (SWIG_arg_fail(2)) SWIG_fail;
28865 }
28866 {
28867 arg3 = (int)(SWIG_As_int(obj2));
28868 if (SWIG_arg_fail(3)) SWIG_fail;
28869 }
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28873
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 {
28878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28879 }
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj;
28888 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28889 int arg2 ;
28890 int arg3 ;
28891 wxDragResult arg4 ;
28892 wxDragResult result;
28893 PyObject * obj0 = 0 ;
28894 PyObject * obj1 = 0 ;
28895 PyObject * obj2 = 0 ;
28896 PyObject * obj3 = 0 ;
28897 char *kwnames[] = {
28898 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28899 };
28900
28901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28903 if (SWIG_arg_fail(1)) SWIG_fail;
28904 {
28905 arg2 = (int)(SWIG_As_int(obj1));
28906 if (SWIG_arg_fail(2)) SWIG_fail;
28907 }
28908 {
28909 arg3 = (int)(SWIG_As_int(obj2));
28910 if (SWIG_arg_fail(3)) SWIG_fail;
28911 }
28912 {
28913 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28914 if (SWIG_arg_fail(4)) SWIG_fail;
28915 }
28916 {
28917 PyThreadState* __tstate = wxPyBeginAllowThreads();
28918 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
28919
28920 wxPyEndAllowThreads(__tstate);
28921 if (PyErr_Occurred()) SWIG_fail;
28922 }
28923 resultobj = SWIG_From_int((result));
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
28931 PyObject *obj;
28932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28933 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
28934 Py_INCREF(obj);
28935 return Py_BuildValue((char *)"");
28936 }
28937 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28938 PyObject *resultobj;
28939 wxPyFileDropTarget *result;
28940 char *kwnames[] = {
28941 NULL
28942 };
28943
28944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
28948
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28960 PyObject *resultobj;
28961 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
28962 PyObject *arg2 = (PyObject *) 0 ;
28963 PyObject *arg3 = (PyObject *) 0 ;
28964 PyObject * obj0 = 0 ;
28965 PyObject * obj1 = 0 ;
28966 PyObject * obj2 = 0 ;
28967 char *kwnames[] = {
28968 (char *) "self",(char *) "self",(char *) "_class", NULL
28969 };
28970
28971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
28973 if (SWIG_arg_fail(1)) SWIG_fail;
28974 arg2 = obj1;
28975 arg3 = obj2;
28976 {
28977 PyThreadState* __tstate = wxPyBeginAllowThreads();
28978 (arg1)->_setCallbackInfo(arg2,arg3);
28979
28980 wxPyEndAllowThreads(__tstate);
28981 if (PyErr_Occurred()) SWIG_fail;
28982 }
28983 Py_INCREF(Py_None); resultobj = Py_None;
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28991 PyObject *resultobj;
28992 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
28993 int arg2 ;
28994 int arg3 ;
28995 wxDragResult arg4 ;
28996 wxDragResult result;
28997 PyObject * obj0 = 0 ;
28998 PyObject * obj1 = 0 ;
28999 PyObject * obj2 = 0 ;
29000 PyObject * obj3 = 0 ;
29001 char *kwnames[] = {
29002 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29003 };
29004
29005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29007 if (SWIG_arg_fail(1)) SWIG_fail;
29008 {
29009 arg2 = (int)(SWIG_As_int(obj1));
29010 if (SWIG_arg_fail(2)) SWIG_fail;
29011 }
29012 {
29013 arg3 = (int)(SWIG_As_int(obj2));
29014 if (SWIG_arg_fail(3)) SWIG_fail;
29015 }
29016 {
29017 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29018 if (SWIG_arg_fail(4)) SWIG_fail;
29019 }
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29023
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_From_int((result));
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj;
29036 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29037 int arg2 ;
29038 int arg3 ;
29039 wxDragResult arg4 ;
29040 wxDragResult result;
29041 PyObject * obj0 = 0 ;
29042 PyObject * obj1 = 0 ;
29043 PyObject * obj2 = 0 ;
29044 PyObject * obj3 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 arg2 = (int)(SWIG_As_int(obj1));
29054 if (SWIG_arg_fail(2)) SWIG_fail;
29055 }
29056 {
29057 arg3 = (int)(SWIG_As_int(obj2));
29058 if (SWIG_arg_fail(3)) SWIG_fail;
29059 }
29060 {
29061 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29062 if (SWIG_arg_fail(4)) SWIG_fail;
29063 }
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29067
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_From_int((result));
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj;
29080 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29081 PyObject * obj0 = 0 ;
29082 char *kwnames[] = {
29083 (char *) "self", NULL
29084 };
29085
29086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29088 if (SWIG_arg_fail(1)) SWIG_fail;
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 (arg1)->base_OnLeave();
29092
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 Py_INCREF(Py_None); resultobj = Py_None;
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29104 PyObject *resultobj;
29105 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29106 int arg2 ;
29107 int arg3 ;
29108 bool result;
29109 PyObject * obj0 = 0 ;
29110 PyObject * obj1 = 0 ;
29111 PyObject * obj2 = 0 ;
29112 char *kwnames[] = {
29113 (char *) "self",(char *) "x",(char *) "y", NULL
29114 };
29115
29116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29118 if (SWIG_arg_fail(1)) SWIG_fail;
29119 {
29120 arg2 = (int)(SWIG_As_int(obj1));
29121 if (SWIG_arg_fail(2)) SWIG_fail;
29122 }
29123 {
29124 arg3 = (int)(SWIG_As_int(obj2));
29125 if (SWIG_arg_fail(3)) SWIG_fail;
29126 }
29127 {
29128 PyThreadState* __tstate = wxPyBeginAllowThreads();
29129 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29130
29131 wxPyEndAllowThreads(__tstate);
29132 if (PyErr_Occurred()) SWIG_fail;
29133 }
29134 {
29135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29136 }
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29144 PyObject *resultobj;
29145 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29146 int arg2 ;
29147 int arg3 ;
29148 wxDragResult arg4 ;
29149 wxDragResult result;
29150 PyObject * obj0 = 0 ;
29151 PyObject * obj1 = 0 ;
29152 PyObject * obj2 = 0 ;
29153 PyObject * obj3 = 0 ;
29154 char *kwnames[] = {
29155 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29156 };
29157
29158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29160 if (SWIG_arg_fail(1)) SWIG_fail;
29161 {
29162 arg2 = (int)(SWIG_As_int(obj1));
29163 if (SWIG_arg_fail(2)) SWIG_fail;
29164 }
29165 {
29166 arg3 = (int)(SWIG_As_int(obj2));
29167 if (SWIG_arg_fail(3)) SWIG_fail;
29168 }
29169 {
29170 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29171 if (SWIG_arg_fail(4)) SWIG_fail;
29172 }
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29176
29177 wxPyEndAllowThreads(__tstate);
29178 if (PyErr_Occurred()) SWIG_fail;
29179 }
29180 resultobj = SWIG_From_int((result));
29181 return resultobj;
29182 fail:
29183 return NULL;
29184 }
29185
29186
29187 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29188 PyObject *obj;
29189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29190 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29191 Py_INCREF(obj);
29192 return Py_BuildValue((char *)"");
29193 }
29194 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29195 PyObject *resultobj;
29196 wxClipboard *result;
29197 char *kwnames[] = {
29198 NULL
29199 };
29200
29201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = (wxClipboard *)new wxClipboard();
29205
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxClipboard *arg1 = (wxClipboard *) 0 ;
29219 PyObject * obj0 = 0 ;
29220 char *kwnames[] = {
29221 (char *) "self", NULL
29222 };
29223
29224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29226 if (SWIG_arg_fail(1)) SWIG_fail;
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 delete arg1;
29230
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 Py_INCREF(Py_None); resultobj = Py_None;
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29242 PyObject *resultobj;
29243 wxClipboard *arg1 = (wxClipboard *) 0 ;
29244 bool result;
29245 PyObject * obj0 = 0 ;
29246 char *kwnames[] = {
29247 (char *) "self", NULL
29248 };
29249
29250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29252 if (SWIG_arg_fail(1)) SWIG_fail;
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 result = (bool)(arg1)->Open();
29256
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 {
29261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29262 }
29263 return resultobj;
29264 fail:
29265 return NULL;
29266 }
29267
29268
29269 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29270 PyObject *resultobj;
29271 wxClipboard *arg1 = (wxClipboard *) 0 ;
29272 PyObject * obj0 = 0 ;
29273 char *kwnames[] = {
29274 (char *) "self", NULL
29275 };
29276
29277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29279 if (SWIG_arg_fail(1)) SWIG_fail;
29280 {
29281 PyThreadState* __tstate = wxPyBeginAllowThreads();
29282 (arg1)->Close();
29283
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 Py_INCREF(Py_None); resultobj = Py_None;
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29295 PyObject *resultobj;
29296 wxClipboard *arg1 = (wxClipboard *) 0 ;
29297 bool result;
29298 PyObject * obj0 = 0 ;
29299 char *kwnames[] = {
29300 (char *) "self", NULL
29301 };
29302
29303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29305 if (SWIG_arg_fail(1)) SWIG_fail;
29306 {
29307 PyThreadState* __tstate = wxPyBeginAllowThreads();
29308 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29309
29310 wxPyEndAllowThreads(__tstate);
29311 if (PyErr_Occurred()) SWIG_fail;
29312 }
29313 {
29314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29315 }
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29323 PyObject *resultobj;
29324 wxClipboard *arg1 = (wxClipboard *) 0 ;
29325 wxDataObject *arg2 = (wxDataObject *) 0 ;
29326 bool result;
29327 PyObject * obj0 = 0 ;
29328 PyObject * obj1 = 0 ;
29329 char *kwnames[] = {
29330 (char *) "self",(char *) "data", NULL
29331 };
29332
29333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29335 if (SWIG_arg_fail(1)) SWIG_fail;
29336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29337 if (SWIG_arg_fail(2)) SWIG_fail;
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 result = (bool)(arg1)->AddData(arg2);
29341
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 {
29346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29347 }
29348 return resultobj;
29349 fail:
29350 return NULL;
29351 }
29352
29353
29354 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29355 PyObject *resultobj;
29356 wxClipboard *arg1 = (wxClipboard *) 0 ;
29357 wxDataObject *arg2 = (wxDataObject *) 0 ;
29358 bool result;
29359 PyObject * obj0 = 0 ;
29360 PyObject * obj1 = 0 ;
29361 char *kwnames[] = {
29362 (char *) "self",(char *) "data", NULL
29363 };
29364
29365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29367 if (SWIG_arg_fail(1)) SWIG_fail;
29368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29369 if (SWIG_arg_fail(2)) SWIG_fail;
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 result = (bool)(arg1)->SetData(arg2);
29373
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 {
29378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29379 }
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29387 PyObject *resultobj;
29388 wxClipboard *arg1 = (wxClipboard *) 0 ;
29389 wxDataFormat *arg2 = 0 ;
29390 bool result;
29391 PyObject * obj0 = 0 ;
29392 PyObject * obj1 = 0 ;
29393 char *kwnames[] = {
29394 (char *) "self",(char *) "format", NULL
29395 };
29396
29397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29399 if (SWIG_arg_fail(1)) SWIG_fail;
29400 {
29401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29402 if (SWIG_arg_fail(2)) SWIG_fail;
29403 if (arg2 == NULL) {
29404 SWIG_null_ref("wxDataFormat");
29405 }
29406 if (SWIG_arg_fail(2)) SWIG_fail;
29407 }
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29411
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 {
29416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29417 }
29418 return resultobj;
29419 fail:
29420 return NULL;
29421 }
29422
29423
29424 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29425 PyObject *resultobj;
29426 wxClipboard *arg1 = (wxClipboard *) 0 ;
29427 wxDataObject *arg2 = 0 ;
29428 bool result;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 char *kwnames[] = {
29432 (char *) "self",(char *) "data", NULL
29433 };
29434
29435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29437 if (SWIG_arg_fail(1)) SWIG_fail;
29438 {
29439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29440 if (SWIG_arg_fail(2)) SWIG_fail;
29441 if (arg2 == NULL) {
29442 SWIG_null_ref("wxDataObject");
29443 }
29444 if (SWIG_arg_fail(2)) SWIG_fail;
29445 }
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (bool)(arg1)->GetData(*arg2);
29449
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 {
29454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29455 }
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj;
29464 wxClipboard *arg1 = (wxClipboard *) 0 ;
29465 PyObject * obj0 = 0 ;
29466 char *kwnames[] = {
29467 (char *) "self", NULL
29468 };
29469
29470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29472 if (SWIG_arg_fail(1)) SWIG_fail;
29473 {
29474 PyThreadState* __tstate = wxPyBeginAllowThreads();
29475 (arg1)->Clear();
29476
29477 wxPyEndAllowThreads(__tstate);
29478 if (PyErr_Occurred()) SWIG_fail;
29479 }
29480 Py_INCREF(Py_None); resultobj = Py_None;
29481 return resultobj;
29482 fail:
29483 return NULL;
29484 }
29485
29486
29487 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj;
29489 wxClipboard *arg1 = (wxClipboard *) 0 ;
29490 bool result;
29491 PyObject * obj0 = 0 ;
29492 char *kwnames[] = {
29493 (char *) "self", NULL
29494 };
29495
29496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29498 if (SWIG_arg_fail(1)) SWIG_fail;
29499 {
29500 PyThreadState* __tstate = wxPyBeginAllowThreads();
29501 result = (bool)(arg1)->Flush();
29502
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 {
29507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29508 }
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj;
29517 wxClipboard *arg1 = (wxClipboard *) 0 ;
29518 bool arg2 = (bool) true ;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 char *kwnames[] = {
29522 (char *) "self",(char *) "primary", NULL
29523 };
29524
29525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29527 if (SWIG_arg_fail(1)) SWIG_fail;
29528 if (obj1) {
29529 {
29530 arg2 = (bool)(SWIG_As_bool(obj1));
29531 if (SWIG_arg_fail(2)) SWIG_fail;
29532 }
29533 }
29534 {
29535 PyThreadState* __tstate = wxPyBeginAllowThreads();
29536 (arg1)->UsePrimarySelection(arg2);
29537
29538 wxPyEndAllowThreads(__tstate);
29539 if (PyErr_Occurred()) SWIG_fail;
29540 }
29541 Py_INCREF(Py_None); resultobj = Py_None;
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29549 PyObject *resultobj;
29550 wxClipboard *result;
29551 char *kwnames[] = {
29552 NULL
29553 };
29554
29555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29556 {
29557 PyThreadState* __tstate = wxPyBeginAllowThreads();
29558 result = (wxClipboard *)wxClipboard::Get();
29559
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29564 return resultobj;
29565 fail:
29566 return NULL;
29567 }
29568
29569
29570 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29571 PyObject *obj;
29572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29573 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29574 Py_INCREF(obj);
29575 return Py_BuildValue((char *)"");
29576 }
29577 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29578 PyObject *resultobj;
29579 wxClipboard *arg1 = (wxClipboard *) NULL ;
29580 wxClipboardLocker *result;
29581 PyObject * obj0 = 0 ;
29582 char *kwnames[] = {
29583 (char *) "clipboard", NULL
29584 };
29585
29586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29587 if (obj0) {
29588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29589 if (SWIG_arg_fail(1)) SWIG_fail;
29590 }
29591 {
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29594
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29606 PyObject *resultobj;
29607 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29608 PyObject * obj0 = 0 ;
29609 char *kwnames[] = {
29610 (char *) "self", NULL
29611 };
29612
29613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29615 if (SWIG_arg_fail(1)) SWIG_fail;
29616 {
29617 PyThreadState* __tstate = wxPyBeginAllowThreads();
29618 delete arg1;
29619
29620 wxPyEndAllowThreads(__tstate);
29621 if (PyErr_Occurred()) SWIG_fail;
29622 }
29623 Py_INCREF(Py_None); resultobj = Py_None;
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj;
29632 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29633 bool result;
29634 PyObject * obj0 = 0 ;
29635 char *kwnames[] = {
29636 (char *) "self", NULL
29637 };
29638
29639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29641 if (SWIG_arg_fail(1)) SWIG_fail;
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (bool)wxClipboardLocker___nonzero__(arg1);
29645
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 {
29650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29651 }
29652 return resultobj;
29653 fail:
29654 return NULL;
29655 }
29656
29657
29658 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29659 PyObject *obj;
29660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29661 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29662 Py_INCREF(obj);
29663 return Py_BuildValue((char *)"");
29664 }
29665 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29666 PyObject *resultobj;
29667 int arg1 = (int) 0 ;
29668 int arg2 = (int) 0 ;
29669 int arg3 = (int) 0 ;
29670 int arg4 = (int) 0 ;
29671 wxVideoMode *result;
29672 PyObject * obj0 = 0 ;
29673 PyObject * obj1 = 0 ;
29674 PyObject * obj2 = 0 ;
29675 PyObject * obj3 = 0 ;
29676 char *kwnames[] = {
29677 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29678 };
29679
29680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29681 if (obj0) {
29682 {
29683 arg1 = (int)(SWIG_As_int(obj0));
29684 if (SWIG_arg_fail(1)) SWIG_fail;
29685 }
29686 }
29687 if (obj1) {
29688 {
29689 arg2 = (int)(SWIG_As_int(obj1));
29690 if (SWIG_arg_fail(2)) SWIG_fail;
29691 }
29692 }
29693 if (obj2) {
29694 {
29695 arg3 = (int)(SWIG_As_int(obj2));
29696 if (SWIG_arg_fail(3)) SWIG_fail;
29697 }
29698 }
29699 if (obj3) {
29700 {
29701 arg4 = (int)(SWIG_As_int(obj3));
29702 if (SWIG_arg_fail(4)) SWIG_fail;
29703 }
29704 }
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29708
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29720 PyObject *resultobj;
29721 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29722 PyObject * obj0 = 0 ;
29723 char *kwnames[] = {
29724 (char *) "self", NULL
29725 };
29726
29727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29729 if (SWIG_arg_fail(1)) SWIG_fail;
29730 {
29731 PyThreadState* __tstate = wxPyBeginAllowThreads();
29732 delete arg1;
29733
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 Py_INCREF(Py_None); resultobj = Py_None;
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj;
29746 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29747 wxVideoMode *arg2 = 0 ;
29748 bool result;
29749 PyObject * obj0 = 0 ;
29750 PyObject * obj1 = 0 ;
29751 char *kwnames[] = {
29752 (char *) "self",(char *) "other", NULL
29753 };
29754
29755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29757 if (SWIG_arg_fail(1)) SWIG_fail;
29758 {
29759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29760 if (SWIG_arg_fail(2)) SWIG_fail;
29761 if (arg2 == NULL) {
29762 SWIG_null_ref("wxVideoMode");
29763 }
29764 if (SWIG_arg_fail(2)) SWIG_fail;
29765 }
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 {
29774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29775 }
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29785 int result;
29786 PyObject * obj0 = 0 ;
29787 char *kwnames[] = {
29788 (char *) "self", NULL
29789 };
29790
29791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29793 if (SWIG_arg_fail(1)) SWIG_fail;
29794 {
29795 PyThreadState* __tstate = wxPyBeginAllowThreads();
29796 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29797
29798 wxPyEndAllowThreads(__tstate);
29799 if (PyErr_Occurred()) SWIG_fail;
29800 }
29801 {
29802 resultobj = SWIG_From_int((int)(result));
29803 }
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29811 PyObject *resultobj;
29812 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29813 int result;
29814 PyObject * obj0 = 0 ;
29815 char *kwnames[] = {
29816 (char *) "self", NULL
29817 };
29818
29819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29821 if (SWIG_arg_fail(1)) SWIG_fail;
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 {
29830 resultobj = SWIG_From_int((int)(result));
29831 }
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29841 int result;
29842 PyObject * obj0 = 0 ;
29843 char *kwnames[] = {
29844 (char *) "self", NULL
29845 };
29846
29847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29849 if (SWIG_arg_fail(1)) SWIG_fail;
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29853
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 {
29858 resultobj = SWIG_From_int((int)(result));
29859 }
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj;
29868 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29869 bool result;
29870 PyObject * obj0 = 0 ;
29871 char *kwnames[] = {
29872 (char *) "self", NULL
29873 };
29874
29875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
29876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29877 if (SWIG_arg_fail(1)) SWIG_fail;
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29881
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 {
29886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29887 }
29888 return resultobj;
29889 fail:
29890 return NULL;
29891 }
29892
29893
29894 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29895 PyObject *resultobj;
29896 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29897 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29898 bool result;
29899 PyObject * obj0 = 0 ;
29900 PyObject * obj1 = 0 ;
29901 char *kwnames[] = {
29902 (char *) "self",(char *) "other", NULL
29903 };
29904
29905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29907 if (SWIG_arg_fail(1)) SWIG_fail;
29908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29909 if (SWIG_arg_fail(2)) SWIG_fail;
29910 {
29911 PyThreadState* __tstate = wxPyBeginAllowThreads();
29912 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
29913
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 {
29918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29919 }
29920 return resultobj;
29921 fail:
29922 return NULL;
29923 }
29924
29925
29926 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
29927 PyObject *resultobj;
29928 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29929 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29930 bool result;
29931 PyObject * obj0 = 0 ;
29932 PyObject * obj1 = 0 ;
29933 char *kwnames[] = {
29934 (char *) "self",(char *) "other", NULL
29935 };
29936
29937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
29938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29939 if (SWIG_arg_fail(1)) SWIG_fail;
29940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29941 if (SWIG_arg_fail(2)) SWIG_fail;
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
29945
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 {
29950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29951 }
29952 return resultobj;
29953 fail:
29954 return NULL;
29955 }
29956
29957
29958 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
29959 PyObject *resultobj;
29960 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29961 int arg2 ;
29962 PyObject * obj0 = 0 ;
29963 PyObject * obj1 = 0 ;
29964 char *kwnames[] = {
29965 (char *) "self",(char *) "w", NULL
29966 };
29967
29968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
29969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29970 if (SWIG_arg_fail(1)) SWIG_fail;
29971 {
29972 arg2 = (int)(SWIG_As_int(obj1));
29973 if (SWIG_arg_fail(2)) SWIG_fail;
29974 }
29975 if (arg1) (arg1)->w = arg2;
29976
29977 Py_INCREF(Py_None); resultobj = Py_None;
29978 return resultobj;
29979 fail:
29980 return NULL;
29981 }
29982
29983
29984 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
29985 PyObject *resultobj;
29986 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29987 int result;
29988 PyObject * obj0 = 0 ;
29989 char *kwnames[] = {
29990 (char *) "self", NULL
29991 };
29992
29993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
29994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29995 if (SWIG_arg_fail(1)) SWIG_fail;
29996 result = (int) ((arg1)->w);
29997
29998 {
29999 resultobj = SWIG_From_int((int)(result));
30000 }
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj;
30009 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30010 int arg2 ;
30011 PyObject * obj0 = 0 ;
30012 PyObject * obj1 = 0 ;
30013 char *kwnames[] = {
30014 (char *) "self",(char *) "h", NULL
30015 };
30016
30017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30019 if (SWIG_arg_fail(1)) SWIG_fail;
30020 {
30021 arg2 = (int)(SWIG_As_int(obj1));
30022 if (SWIG_arg_fail(2)) SWIG_fail;
30023 }
30024 if (arg1) (arg1)->h = arg2;
30025
30026 Py_INCREF(Py_None); resultobj = Py_None;
30027 return resultobj;
30028 fail:
30029 return NULL;
30030 }
30031
30032
30033 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30034 PyObject *resultobj;
30035 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30036 int result;
30037 PyObject * obj0 = 0 ;
30038 char *kwnames[] = {
30039 (char *) "self", NULL
30040 };
30041
30042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30044 if (SWIG_arg_fail(1)) SWIG_fail;
30045 result = (int) ((arg1)->h);
30046
30047 {
30048 resultobj = SWIG_From_int((int)(result));
30049 }
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj;
30058 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30059 int arg2 ;
30060 PyObject * obj0 = 0 ;
30061 PyObject * obj1 = 0 ;
30062 char *kwnames[] = {
30063 (char *) "self",(char *) "bpp", NULL
30064 };
30065
30066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30068 if (SWIG_arg_fail(1)) SWIG_fail;
30069 {
30070 arg2 = (int)(SWIG_As_int(obj1));
30071 if (SWIG_arg_fail(2)) SWIG_fail;
30072 }
30073 if (arg1) (arg1)->bpp = arg2;
30074
30075 Py_INCREF(Py_None); resultobj = Py_None;
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj;
30084 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30085 int result;
30086 PyObject * obj0 = 0 ;
30087 char *kwnames[] = {
30088 (char *) "self", NULL
30089 };
30090
30091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30093 if (SWIG_arg_fail(1)) SWIG_fail;
30094 result = (int) ((arg1)->bpp);
30095
30096 {
30097 resultobj = SWIG_From_int((int)(result));
30098 }
30099 return resultobj;
30100 fail:
30101 return NULL;
30102 }
30103
30104
30105 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30106 PyObject *resultobj;
30107 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30108 int arg2 ;
30109 PyObject * obj0 = 0 ;
30110 PyObject * obj1 = 0 ;
30111 char *kwnames[] = {
30112 (char *) "self",(char *) "refresh", NULL
30113 };
30114
30115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30117 if (SWIG_arg_fail(1)) SWIG_fail;
30118 {
30119 arg2 = (int)(SWIG_As_int(obj1));
30120 if (SWIG_arg_fail(2)) SWIG_fail;
30121 }
30122 if (arg1) (arg1)->refresh = arg2;
30123
30124 Py_INCREF(Py_None); resultobj = Py_None;
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30132 PyObject *resultobj;
30133 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30134 int result;
30135 PyObject * obj0 = 0 ;
30136 char *kwnames[] = {
30137 (char *) "self", NULL
30138 };
30139
30140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30142 if (SWIG_arg_fail(1)) SWIG_fail;
30143 result = (int) ((arg1)->refresh);
30144
30145 {
30146 resultobj = SWIG_From_int((int)(result));
30147 }
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30155 PyObject *obj;
30156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30157 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30158 Py_INCREF(obj);
30159 return Py_BuildValue((char *)"");
30160 }
30161 static int _wrap_DefaultVideoMode_set(PyObject *) {
30162 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30163 return 1;
30164 }
30165
30166
30167 static PyObject *_wrap_DefaultVideoMode_get(void) {
30168 PyObject *pyobj;
30169
30170 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30171 return pyobj;
30172 }
30173
30174
30175 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj;
30177 size_t arg1 = (size_t) 0 ;
30178 wxDisplay *result;
30179 PyObject * obj0 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "index", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30185 if (obj0) {
30186 {
30187 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 }
30190 }
30191 {
30192 PyThreadState* __tstate = wxPyBeginAllowThreads();
30193 result = (wxDisplay *)new wxDisplay(arg1);
30194
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30199 return resultobj;
30200 fail:
30201 return NULL;
30202 }
30203
30204
30205 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj;
30207 wxDisplay *arg1 = (wxDisplay *) 0 ;
30208 PyObject * obj0 = 0 ;
30209 char *kwnames[] = {
30210 (char *) "self", NULL
30211 };
30212
30213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30215 if (SWIG_arg_fail(1)) SWIG_fail;
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 delete arg1;
30219
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 Py_INCREF(Py_None); resultobj = Py_None;
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj;
30232 size_t result;
30233 char *kwnames[] = {
30234 NULL
30235 };
30236
30237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30238 {
30239 PyThreadState* __tstate = wxPyBeginAllowThreads();
30240 result = (size_t)wxDisplay::GetCount();
30241
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 {
30246 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30247 }
30248 return resultobj;
30249 fail:
30250 return NULL;
30251 }
30252
30253
30254 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30255 PyObject *resultobj;
30256 wxPoint *arg1 = 0 ;
30257 int result;
30258 wxPoint temp1 ;
30259 PyObject * obj0 = 0 ;
30260 char *kwnames[] = {
30261 (char *) "pt", NULL
30262 };
30263
30264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30265 {
30266 arg1 = &temp1;
30267 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30268 }
30269 {
30270 PyThreadState* __tstate = wxPyBeginAllowThreads();
30271 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30272
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 {
30277 resultobj = SWIG_From_int((int)(result));
30278 }
30279 return resultobj;
30280 fail:
30281 return NULL;
30282 }
30283
30284
30285 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30286 PyObject *resultobj;
30287 wxWindow *arg1 = (wxWindow *) 0 ;
30288 int result;
30289 PyObject * obj0 = 0 ;
30290 char *kwnames[] = {
30291 (char *) "window", NULL
30292 };
30293
30294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30296 if (SWIG_arg_fail(1)) SWIG_fail;
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (int)Display_GetFromWindow(arg1);
30300
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 {
30305 resultobj = SWIG_From_int((int)(result));
30306 }
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30314 PyObject *resultobj;
30315 wxDisplay *arg1 = (wxDisplay *) 0 ;
30316 bool result;
30317 PyObject * obj0 = 0 ;
30318 char *kwnames[] = {
30319 (char *) "self", NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30324 if (SWIG_arg_fail(1)) SWIG_fail;
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (bool)((wxDisplay const *)arg1)->IsOk();
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 {
30333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30334 }
30335 return resultobj;
30336 fail:
30337 return NULL;
30338 }
30339
30340
30341 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj;
30343 wxDisplay *arg1 = (wxDisplay *) 0 ;
30344 wxRect result;
30345 PyObject * obj0 = 0 ;
30346 char *kwnames[] = {
30347 (char *) "self", NULL
30348 };
30349
30350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30352 if (SWIG_arg_fail(1)) SWIG_fail;
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 result = ((wxDisplay const *)arg1)->GetGeometry();
30356
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 {
30361 wxRect * resultptr;
30362 resultptr = new wxRect((wxRect &)(result));
30363 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30364 }
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxDisplay *arg1 = (wxDisplay *) 0 ;
30374 wxString result;
30375 PyObject * obj0 = 0 ;
30376 char *kwnames[] = {
30377 (char *) "self", NULL
30378 };
30379
30380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30382 if (SWIG_arg_fail(1)) SWIG_fail;
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = ((wxDisplay const *)arg1)->GetName();
30386
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 {
30391 #if wxUSE_UNICODE
30392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30393 #else
30394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30395 #endif
30396 }
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj;
30405 wxDisplay *arg1 = (wxDisplay *) 0 ;
30406 bool result;
30407 PyObject * obj0 = 0 ;
30408 char *kwnames[] = {
30409 (char *) "self", NULL
30410 };
30411
30412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30414 if (SWIG_arg_fail(1)) SWIG_fail;
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 {
30423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 wxDisplay *arg1 = (wxDisplay *) 0 ;
30434 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30435 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30436 PyObject *result;
30437 PyObject * obj0 = 0 ;
30438 PyObject * obj1 = 0 ;
30439 char *kwnames[] = {
30440 (char *) "self",(char *) "mode", NULL
30441 };
30442
30443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30445 if (SWIG_arg_fail(1)) SWIG_fail;
30446 if (obj1) {
30447 {
30448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30449 if (SWIG_arg_fail(2)) SWIG_fail;
30450 if (arg2 == NULL) {
30451 SWIG_null_ref("wxVideoMode");
30452 }
30453 if (SWIG_arg_fail(2)) SWIG_fail;
30454 }
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30459
30460 wxPyEndAllowThreads(__tstate);
30461 if (PyErr_Occurred()) SWIG_fail;
30462 }
30463 resultobj = result;
30464 return resultobj;
30465 fail:
30466 return NULL;
30467 }
30468
30469
30470 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30471 PyObject *resultobj;
30472 wxDisplay *arg1 = (wxDisplay *) 0 ;
30473 wxVideoMode result;
30474 PyObject * obj0 = 0 ;
30475 char *kwnames[] = {
30476 (char *) "self", NULL
30477 };
30478
30479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30481 if (SWIG_arg_fail(1)) SWIG_fail;
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30485
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 {
30490 wxVideoMode * resultptr;
30491 resultptr = new wxVideoMode((wxVideoMode &)(result));
30492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30493 }
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj;
30502 wxDisplay *arg1 = (wxDisplay *) 0 ;
30503 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30504 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30505 bool result;
30506 PyObject * obj0 = 0 ;
30507 PyObject * obj1 = 0 ;
30508 char *kwnames[] = {
30509 (char *) "self",(char *) "mode", NULL
30510 };
30511
30512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30514 if (SWIG_arg_fail(1)) SWIG_fail;
30515 if (obj1) {
30516 {
30517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30518 if (SWIG_arg_fail(2)) SWIG_fail;
30519 if (arg2 == NULL) {
30520 SWIG_null_ref("wxVideoMode");
30521 }
30522 if (SWIG_arg_fail(2)) SWIG_fail;
30523 }
30524 }
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30528
30529 wxPyEndAllowThreads(__tstate);
30530 if (PyErr_Occurred()) SWIG_fail;
30531 }
30532 {
30533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30534 }
30535 return resultobj;
30536 fail:
30537 return NULL;
30538 }
30539
30540
30541 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30542 PyObject *resultobj;
30543 wxDisplay *arg1 = (wxDisplay *) 0 ;
30544 PyObject * obj0 = 0 ;
30545 char *kwnames[] = {
30546 (char *) "self", NULL
30547 };
30548
30549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30551 if (SWIG_arg_fail(1)) SWIG_fail;
30552 {
30553 PyThreadState* __tstate = wxPyBeginAllowThreads();
30554 (arg1)->ResetMode();
30555
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 Py_INCREF(Py_None); resultobj = Py_None;
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30567 PyObject *obj;
30568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30569 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30570 Py_INCREF(obj);
30571 return Py_BuildValue((char *)"");
30572 }
30573 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30574 PyObject *resultobj;
30575 wxStandardPaths *result;
30576 char *kwnames[] = {
30577 NULL
30578 };
30579
30580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 result = (wxStandardPaths *)StandardPaths_Get();
30584
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30589 return resultobj;
30590 fail:
30591 return NULL;
30592 }
30593
30594
30595 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30596 PyObject *resultobj;
30597 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30598 wxString result;
30599 PyObject * obj0 = 0 ;
30600 char *kwnames[] = {
30601 (char *) "self", NULL
30602 };
30603
30604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30606 if (SWIG_arg_fail(1)) SWIG_fail;
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30610
30611 wxPyEndAllowThreads(__tstate);
30612 if (PyErr_Occurred()) SWIG_fail;
30613 }
30614 {
30615 #if wxUSE_UNICODE
30616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30617 #else
30618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30619 #endif
30620 }
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30630 wxString result;
30631 PyObject * obj0 = 0 ;
30632 char *kwnames[] = {
30633 (char *) "self", NULL
30634 };
30635
30636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30638 if (SWIG_arg_fail(1)) SWIG_fail;
30639 {
30640 PyThreadState* __tstate = wxPyBeginAllowThreads();
30641 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30642
30643 wxPyEndAllowThreads(__tstate);
30644 if (PyErr_Occurred()) SWIG_fail;
30645 }
30646 {
30647 #if wxUSE_UNICODE
30648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30649 #else
30650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30651 #endif
30652 }
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj;
30661 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30662 wxString result;
30663 PyObject * obj0 = 0 ;
30664 char *kwnames[] = {
30665 (char *) "self", NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30674
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 {
30679 #if wxUSE_UNICODE
30680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30681 #else
30682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30683 #endif
30684 }
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj;
30693 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30694 wxString result;
30695 PyObject * obj0 = 0 ;
30696 char *kwnames[] = {
30697 (char *) "self", NULL
30698 };
30699
30700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30702 if (SWIG_arg_fail(1)) SWIG_fail;
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30706
30707 wxPyEndAllowThreads(__tstate);
30708 if (PyErr_Occurred()) SWIG_fail;
30709 }
30710 {
30711 #if wxUSE_UNICODE
30712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30713 #else
30714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30715 #endif
30716 }
30717 return resultobj;
30718 fail:
30719 return NULL;
30720 }
30721
30722
30723 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30724 PyObject *resultobj;
30725 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30726 wxString result;
30727 PyObject * obj0 = 0 ;
30728 char *kwnames[] = {
30729 (char *) "self", NULL
30730 };
30731
30732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30734 if (SWIG_arg_fail(1)) SWIG_fail;
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30738
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 {
30743 #if wxUSE_UNICODE
30744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30745 #else
30746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30747 #endif
30748 }
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30756 PyObject *resultobj;
30757 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30758 wxString result;
30759 PyObject * obj0 = 0 ;
30760 char *kwnames[] = {
30761 (char *) "self", NULL
30762 };
30763
30764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30766 if (SWIG_arg_fail(1)) SWIG_fail;
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30770
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 {
30775 #if wxUSE_UNICODE
30776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30777 #else
30778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30779 #endif
30780 }
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30788 PyObject *resultobj;
30789 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30790 wxString result;
30791 PyObject * obj0 = 0 ;
30792 char *kwnames[] = {
30793 (char *) "self", NULL
30794 };
30795
30796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30798 if (SWIG_arg_fail(1)) SWIG_fail;
30799 {
30800 PyThreadState* __tstate = wxPyBeginAllowThreads();
30801 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30802
30803 wxPyEndAllowThreads(__tstate);
30804 if (PyErr_Occurred()) SWIG_fail;
30805 }
30806 {
30807 #if wxUSE_UNICODE
30808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30809 #else
30810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30811 #endif
30812 }
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30820 PyObject *resultobj;
30821 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30822 wxString *arg2 = 0 ;
30823 bool temp2 = false ;
30824 PyObject * obj0 = 0 ;
30825 PyObject * obj1 = 0 ;
30826 char *kwnames[] = {
30827 (char *) "self",(char *) "prefix", NULL
30828 };
30829
30830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30832 if (SWIG_arg_fail(1)) SWIG_fail;
30833 {
30834 arg2 = wxString_in_helper(obj1);
30835 if (arg2 == NULL) SWIG_fail;
30836 temp2 = true;
30837 }
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 (arg1)->SetInstallPrefix((wxString const &)*arg2);
30841
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 Py_INCREF(Py_None); resultobj = Py_None;
30846 {
30847 if (temp2)
30848 delete arg2;
30849 }
30850 return resultobj;
30851 fail:
30852 {
30853 if (temp2)
30854 delete arg2;
30855 }
30856 return NULL;
30857 }
30858
30859
30860 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30861 PyObject *resultobj;
30862 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30863 wxString result;
30864 PyObject * obj0 = 0 ;
30865 char *kwnames[] = {
30866 (char *) "self", NULL
30867 };
30868
30869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30871 if (SWIG_arg_fail(1)) SWIG_fail;
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
30875
30876 wxPyEndAllowThreads(__tstate);
30877 if (PyErr_Occurred()) SWIG_fail;
30878 }
30879 {
30880 #if wxUSE_UNICODE
30881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30882 #else
30883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30884 #endif
30885 }
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30893 PyObject *obj;
30894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30895 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30896 Py_INCREF(obj);
30897 return Py_BuildValue((char *)"");
30898 }
30899 static PyMethodDef SwigMethods[] = {
30900 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30901 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30902 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30903 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30904 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30905 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30906 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
30907 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
30908 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30909 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30910 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30911 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30912 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
30913 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
30914 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
30915 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
30916 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
30917 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
30918 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30919 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30920 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
30921 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30922 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
30923 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
30924 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
30925 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
30926 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
30927 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
30928 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
30929 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
30930 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
30931 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
30932 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
30933 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
30934 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
30935 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
30936 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
30937 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
30938 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
30939 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
30940 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
30941 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
30942 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
30943 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
30944 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
30945 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
30946 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30947 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30948 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30949 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30950 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30951 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30952 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
30953 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
30954 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
30955 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30956 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
30957 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30958 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30959 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
30960 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
30961 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
30962 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
30963 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
30964 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
30965 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30966 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30967 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
30968 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30969 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30970 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
30971 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
30972 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
30973 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
30974 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
30975 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
30976 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
30977 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
30978 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
30979 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
30980 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
30981 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
30982 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
30983 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
30984 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
30985 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
30986 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
30987 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
30989 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
30990 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
30991 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
30992 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
30993 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
30994 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
30999 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31000 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31001 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31002 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31007 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31010 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31013 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31019 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31033 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31039 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31040 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31043 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31044 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31047 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31049 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31061 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31063 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31064 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31065 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31068 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31069 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31095 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31097 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31099 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31100 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31101 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31108 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31114 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31128 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31131 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31132 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31135 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31144 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31152 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31160 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31207 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31225 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31235 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31251 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31267 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31281 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31290 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31333 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31336 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31339 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31343 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31436 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31437 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31438 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31439 { (char *)"DateTime___lt__", _wrap_DateTime___lt__, METH_VARARGS, NULL},
31440 { (char *)"DateTime___le__", _wrap_DateTime___le__, METH_VARARGS, NULL},
31441 { (char *)"DateTime___gt__", _wrap_DateTime___gt__, METH_VARARGS, NULL},
31442 { (char *)"DateTime___ge__", _wrap_DateTime___ge__, METH_VARARGS, NULL},
31443 { (char *)"DateTime___eq__", _wrap_DateTime___eq__, METH_VARARGS, NULL},
31444 { (char *)"DateTime___ne__", _wrap_DateTime___ne__, METH_VARARGS, NULL},
31445 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31456 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31501 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31535 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31543 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31544 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31549 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31558 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31565 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31568 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31571 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31576 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31579 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31583 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31586 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31590 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31591 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31595 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31599 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31601 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31611 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31622 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31630 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31638 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31652 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31656 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31674 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31688 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31699 { NULL, NULL, 0, NULL }
31700 };
31701
31702
31703 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31704
31705 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31706 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31707 }
31708 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31709 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31710 }
31711 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31712 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31713 }
31714 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31715 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31716 }
31717 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31718 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31719 }
31720 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31721 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31722 }
31723 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31724 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31725 }
31726 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31727 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31728 }
31729 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31731 }
31732 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31733 return (void *)((wxEvent *) ((wxPyEvent *) x));
31734 }
31735 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31737 }
31738 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31739 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31740 }
31741 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31742 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31743 }
31744 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31745 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31746 }
31747 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31748 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31749 }
31750 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31751 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31752 }
31753 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31754 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31755 }
31756 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31757 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31758 }
31759 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31760 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31761 }
31762 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31763 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31764 }
31765 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31766 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31767 }
31768 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31769 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31770 }
31771 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31772 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31773 }
31774 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31775 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31776 }
31777 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31778 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31779 }
31780 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31781 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31782 }
31783 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31784 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31785 }
31786 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31787 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31788 }
31789 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31790 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31791 }
31792 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31793 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31794 }
31795 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31796 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31797 }
31798 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31799 return (void *)((wxEvent *) ((wxShowEvent *) x));
31800 }
31801 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31802 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31803 }
31804 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31805 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31806 }
31807 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31808 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31809 }
31810 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31811 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31812 }
31813 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31814 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31815 }
31816 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31817 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31818 }
31819 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31820 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31821 }
31822 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31823 return (void *)((wxConfigBase *) ((wxConfig *) x));
31824 }
31825 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31826 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31827 }
31828 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31829 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31830 }
31831 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31832 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31833 }
31834 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31835 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31836 }
31837 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31838 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31839 }
31840 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31841 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31842 }
31843 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31844 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31845 }
31846 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31847 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31848 }
31849 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31850 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31851 }
31852 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31853 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31854 }
31855 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31856 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31857 }
31858 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31859 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31860 }
31861 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31862 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31863 }
31864 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31865 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31866 }
31867 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31868 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31869 }
31870 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31871 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31872 }
31873 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31874 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31875 }
31876 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31877 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31878 }
31879 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31880 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31881 }
31882 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31883 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31884 }
31885 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31886 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31887 }
31888 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31889 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31890 }
31891 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31892 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31893 }
31894 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31895 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31896 }
31897 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31898 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31899 }
31900 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31901 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31902 }
31903 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31904 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
31905 }
31906 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
31907 return (void *)((wxEvtHandler *) ((wxValidator *) x));
31908 }
31909 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
31910 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
31911 }
31912 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
31913 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
31914 }
31915 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
31916 return (void *)((wxEvtHandler *) ((wxMenu *) x));
31917 }
31918 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
31919 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
31920 }
31921 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
31922 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
31923 }
31924 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
31925 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
31926 }
31927 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
31928 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
31929 }
31930 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
31931 return (void *)((wxObject *) ((wxSizerItem *) x));
31932 }
31933 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
31934 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
31935 }
31936 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
31937 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
31938 }
31939 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
31940 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
31941 }
31942 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
31943 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
31944 }
31945 static void *_p_wxSizerTo_p_wxObject(void *x) {
31946 return (void *)((wxObject *) ((wxSizer *) x));
31947 }
31948 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
31949 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
31950 }
31951 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
31952 return (void *)((wxObject *) ((wxFileHistory *) x));
31953 }
31954 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
31955 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
31956 }
31957 static void *_p_wxEventTo_p_wxObject(void *x) {
31958 return (void *)((wxObject *) ((wxEvent *) x));
31959 }
31960 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
31961 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
31962 }
31963 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
31964 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
31965 }
31966 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
31967 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
31968 }
31969 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
31970 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
31971 }
31972 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
31973 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
31974 }
31975 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
31976 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
31977 }
31978 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
31979 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
31980 }
31981 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
31982 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31983 }
31984 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
31985 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
31986 }
31987 static void *_p_wxControlTo_p_wxObject(void *x) {
31988 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
31989 }
31990 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
31991 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
31992 }
31993 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
31994 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
31995 }
31996 static void *_p_wxFSFileTo_p_wxObject(void *x) {
31997 return (void *)((wxObject *) ((wxFSFile *) x));
31998 }
31999 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32000 return (void *)((wxObject *) ((wxClipboard *) x));
32001 }
32002 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32003 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32004 }
32005 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32006 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32007 }
32008 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32009 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32010 }
32011 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32012 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32013 }
32014 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32015 return (void *)((wxObject *) ((wxToolTip *) x));
32016 }
32017 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32018 return (void *)((wxObject *) ((wxMenuItem *) x));
32019 }
32020 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32021 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32022 }
32023 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32024 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32025 }
32026 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32027 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32028 }
32029 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32030 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32031 }
32032 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32033 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32034 }
32035 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32036 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32037 }
32038 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32039 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32040 }
32041 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32042 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32043 }
32044 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32045 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32046 }
32047 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32048 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32049 }
32050 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32051 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32052 }
32053 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32054 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32055 }
32056 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32057 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32058 }
32059 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32060 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32061 }
32062 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32063 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32064 }
32065 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32066 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32067 }
32068 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32069 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32070 }
32071 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32072 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32073 }
32074 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32075 return (void *)((wxObject *) ((wxImageHandler *) x));
32076 }
32077 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32078 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32079 }
32080 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32081 return (void *)((wxObject *) ((wxEvtHandler *) x));
32082 }
32083 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32084 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32085 }
32086 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32087 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32088 }
32089 static void *_p_wxImageTo_p_wxObject(void *x) {
32090 return (void *)((wxObject *) ((wxImage *) x));
32091 }
32092 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32093 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32094 }
32095 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32096 return (void *)((wxObject *) ((wxSystemOptions *) x));
32097 }
32098 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32099 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32100 }
32101 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32102 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32103 }
32104 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32105 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32106 }
32107 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32108 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32109 }
32110 static void *_p_wxWindowTo_p_wxObject(void *x) {
32111 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32112 }
32113 static void *_p_wxMenuTo_p_wxObject(void *x) {
32114 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32115 }
32116 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32117 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32118 }
32119 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32120 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32121 }
32122 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32123 return (void *)((wxObject *) ((wxFileSystem *) x));
32124 }
32125 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32126 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32127 }
32128 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32129 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32130 }
32131 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32132 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32133 }
32134 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32135 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32136 }
32137 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32138 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32139 }
32140 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32141 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32142 }
32143 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32144 return (void *)((wxObject *) ((wxBusyInfo *) x));
32145 }
32146 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32147 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32148 }
32149 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32150 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32151 }
32152 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32153 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32154 }
32155 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32156 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32157 }
32158 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32159 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32160 }
32161 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32162 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32163 }
32164 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32165 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32166 }
32167 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32168 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32169 }
32170 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32171 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32172 }
32173 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32174 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32175 }
32176 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32177 return (void *)((wxLog *) ((wxLogStderr *) x));
32178 }
32179 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32180 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32181 }
32182 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32183 return (void *)((wxLog *) ((wxLogWindow *) x));
32184 }
32185 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32186 return (void *)((wxLog *) ((wxLogChain *) x));
32187 }
32188 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32189 return (void *)((wxLog *) ((wxLogGui *) x));
32190 }
32191 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32192 return (void *)((wxLog *) ((wxPyLog *) x));
32193 }
32194 static void *_p_wxControlTo_p_wxWindow(void *x) {
32195 return (void *)((wxWindow *) ((wxControl *) x));
32196 }
32197 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32198 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32199 }
32200 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32201 return (void *)((wxWindow *) ((wxMenuBar *) x));
32202 }
32203 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32204 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32205 }
32206 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32207 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32208 }
32209 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}};
32210 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}};
32211 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}};
32212 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}};
32213 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}};
32214 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_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}};
32215 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}};
32216 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}};
32217 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}};
32218 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}};
32219 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}};
32220 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}};
32221 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}};
32222 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}};
32223 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}};
32224 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}};
32225 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}};
32226 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}};
32227 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}};
32228 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}};
32229 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}};
32230 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}};
32231 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}};
32232 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}};
32233 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}};
32234 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}};
32235 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}};
32236 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}};
32237 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}};
32238 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}};
32239 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}};
32240 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}};
32241 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}};
32242 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}};
32243 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}};
32244 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}};
32245 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}};
32246 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}};
32247 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}};
32248 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}};
32249 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}};
32250 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}};
32251 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}};
32252 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}};
32253 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}};
32254 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}};
32255 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}};
32256 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}};
32257 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}};
32258 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}};
32259 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}};
32260 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}};
32261 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}};
32262 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}};
32263 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}};
32264 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}};
32265 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}};
32266 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}};
32267 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}};
32268 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}};
32269 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}};
32270 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}};
32271 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}};
32272 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}};
32273 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}};
32274 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}};
32275 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}};
32276 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}};
32277 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}};
32278 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_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_wxPNGHandler", _p_wxPNGHandlerTo_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_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}};
32279 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}};
32280 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}};
32281 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}};
32282 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}};
32283 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}};
32284 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}};
32285 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}};
32286 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}};
32287 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}};
32288 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}};
32289 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}};
32290 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}};
32291 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}};
32292 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}};
32293 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}};
32294 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}};
32295 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}};
32296 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}};
32297 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}};
32298 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}};
32299 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}};
32300 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}};
32301 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}};
32302 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}};
32303 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}};
32304
32305 static swig_type_info *swig_types_initial[] = {
32306 _swigt__p_wxLogChain,
32307 _swigt__p_wxMutexGuiLocker,
32308 _swigt__p_wxFileHistory,
32309 _swigt__p_wxLog,
32310 _swigt__p_wxMenu,
32311 _swigt__p_wxEvent,
32312 _swigt__p_wxDateTime__TimeZone,
32313 _swigt__p_wxConfigBase,
32314 _swigt__p_wxDisplay,
32315 _swigt__p_wxFileType,
32316 _swigt__p_wxLogGui,
32317 _swigt__p_wxFont,
32318 _swigt__p_wxDataFormat,
32319 _swigt__p_wxTimerEvent,
32320 _swigt__p_wxCaret,
32321 _swigt__ptrdiff_t,
32322 _swigt__std__ptrdiff_t,
32323 _swigt__p_int,
32324 _swigt__p_wxSize,
32325 _swigt__p_wxClipboard,
32326 _swigt__p_wxStopWatch,
32327 _swigt__p_wxClipboardLocker,
32328 _swigt__p_wxIcon,
32329 _swigt__p_wxLogStderr,
32330 _swigt__p_wxLogTextCtrl,
32331 _swigt__p_wxTextCtrl,
32332 _swigt__p_wxBusyCursor,
32333 _swigt__p_wxBitmapDataObject,
32334 _swigt__p_wxTextDataObject,
32335 _swigt__p_wxDataObject,
32336 _swigt__p_wxPyTextDataObject,
32337 _swigt__p_wxPyBitmapDataObject,
32338 _swigt__p_wxFileDataObject,
32339 _swigt__p_wxCustomDataObject,
32340 _swigt__p_wxURLDataObject,
32341 _swigt__p_wxMetafileDataObject,
32342 _swigt__p_wxSound,
32343 _swigt__p_wxTimerRunner,
32344 _swigt__p_wxLogWindow,
32345 _swigt__p_wxTimeSpan,
32346 _swigt__p_wxArrayString,
32347 _swigt__p_wxWindowDisabler,
32348 _swigt__p_form_ops_t,
32349 _swigt__p_wxToolTip,
32350 _swigt__p_wxDataObjectComposite,
32351 _swigt__p_wxFileConfig,
32352 _swigt__p_wxSystemSettings,
32353 _swigt__p_wxVideoMode,
32354 _swigt__p_wxDataObjectSimple,
32355 _swigt__p_wxPyDataObjectSimple,
32356 _swigt__p_wxDuplexMode,
32357 _swigt__p_wxEvtHandler,
32358 _swigt__p_wxRect,
32359 _swigt__p_char,
32360 _swigt__p_wxSingleInstanceChecker,
32361 _swigt__p_wxStandardPaths,
32362 _swigt__p_wxFileTypeInfo,
32363 _swigt__p_wxFrame,
32364 _swigt__p_wxTimer,
32365 _swigt__p_wxPaperSize,
32366 _swigt__p_wxMimeTypesManager,
32367 _swigt__p_wxPyArtProvider,
32368 _swigt__p_wxPyTipProvider,
32369 _swigt__p_wxTipProvider,
32370 _swigt__p_wxJoystick,
32371 _swigt__p_wxSystemOptions,
32372 _swigt__p_wxPoint,
32373 _swigt__p_wxJoystickEvent,
32374 _swigt__p_wxCursor,
32375 _swigt__p_wxObject,
32376 _swigt__p_wxOutputStream,
32377 _swigt__p_wxDateTime,
32378 _swigt__p_wxPyDropSource,
32379 _swigt__p_unsigned_long,
32380 _swigt__p_wxKillError,
32381 _swigt__p_wxWindow,
32382 _swigt__p_wxString,
32383 _swigt__p_wxPyProcess,
32384 _swigt__p_wxBitmap,
32385 _swigt__p_wxConfig,
32386 _swigt__unsigned_int,
32387 _swigt__p_unsigned_int,
32388 _swigt__p_unsigned_char,
32389 _swigt__p_wxChar,
32390 _swigt__p_wxBusyInfo,
32391 _swigt__p_wxPyDropTarget,
32392 _swigt__p_wxPyTextDropTarget,
32393 _swigt__p_wxPyFileDropTarget,
32394 _swigt__p_wxProcessEvent,
32395 _swigt__p_wxPyLog,
32396 _swigt__p_wxLogNull,
32397 _swigt__p_wxColour,
32398 _swigt__p_wxPyTimer,
32399 _swigt__p_wxConfigPathChanger,
32400 _swigt__p_wxDateSpan,
32401 0
32402 };
32403
32404
32405 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32406
32407 static swig_const_info swig_const_table[] = {
32408 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32409 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32410 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32411 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32412 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32413 {0, 0, 0, 0.0, 0, 0}};
32414
32415 #ifdef __cplusplus
32416 }
32417 #endif
32418
32419
32420 #ifdef __cplusplus
32421 extern "C" {
32422 #endif
32423
32424 /* Python-specific SWIG API */
32425 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32426 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32427 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32428
32429 /* -----------------------------------------------------------------------------
32430 * global variable support code.
32431 * ----------------------------------------------------------------------------- */
32432
32433 typedef struct swig_globalvar {
32434 char *name; /* Name of global variable */
32435 PyObject *(*get_attr)(); /* Return the current value */
32436 int (*set_attr)(PyObject *); /* Set the value */
32437 struct swig_globalvar *next;
32438 } swig_globalvar;
32439
32440 typedef struct swig_varlinkobject {
32441 PyObject_HEAD
32442 swig_globalvar *vars;
32443 } swig_varlinkobject;
32444
32445 static PyObject *
32446 swig_varlink_repr(swig_varlinkobject *v) {
32447 v = v;
32448 return PyString_FromString("<Swig global variables>");
32449 }
32450
32451 static int
32452 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32453 swig_globalvar *var;
32454 flags = flags;
32455 fprintf(fp,"Swig global variables { ");
32456 for (var = v->vars; var; var=var->next) {
32457 fprintf(fp,"%s", var->name);
32458 if (var->next) fprintf(fp,", ");
32459 }
32460 fprintf(fp," }\n");
32461 return 0;
32462 }
32463
32464 static PyObject *
32465 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32466 swig_globalvar *var = v->vars;
32467 while (var) {
32468 if (strcmp(var->name,n) == 0) {
32469 return (*var->get_attr)();
32470 }
32471 var = var->next;
32472 }
32473 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32474 return NULL;
32475 }
32476
32477 static int
32478 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32479 swig_globalvar *var = v->vars;
32480 while (var) {
32481 if (strcmp(var->name,n) == 0) {
32482 return (*var->set_attr)(p);
32483 }
32484 var = var->next;
32485 }
32486 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32487 return 1;
32488 }
32489
32490 static PyTypeObject varlinktype = {
32491 PyObject_HEAD_INIT(0)
32492 0, /* Number of items in variable part (ob_size) */
32493 (char *)"swigvarlink", /* Type name (tp_name) */
32494 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32495 0, /* Itemsize (tp_itemsize) */
32496 0, /* Deallocator (tp_dealloc) */
32497 (printfunc) swig_varlink_print, /* Print (tp_print) */
32498 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32499 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32500 0, /* tp_compare */
32501 (reprfunc) swig_varlink_repr, /* tp_repr */
32502 0, /* tp_as_number */
32503 0, /* tp_as_sequence */
32504 0, /* tp_as_mapping */
32505 0, /* tp_hash */
32506 0, /* tp_call */
32507 0, /* tp_str */
32508 0, /* tp_getattro */
32509 0, /* tp_setattro */
32510 0, /* tp_as_buffer */
32511 0, /* tp_flags */
32512 0, /* tp_doc */
32513 #if PY_VERSION_HEX >= 0x02000000
32514 0, /* tp_traverse */
32515 0, /* tp_clear */
32516 #endif
32517 #if PY_VERSION_HEX >= 0x02010000
32518 0, /* tp_richcompare */
32519 0, /* tp_weaklistoffset */
32520 #endif
32521 #if PY_VERSION_HEX >= 0x02020000
32522 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32523 #endif
32524 #if PY_VERSION_HEX >= 0x02030000
32525 0, /* tp_del */
32526 #endif
32527 #ifdef COUNT_ALLOCS
32528 0,0,0,0 /* tp_alloc -> tp_next */
32529 #endif
32530 };
32531
32532 /* Create a variable linking object for use later */
32533 static PyObject *
32534 SWIG_Python_newvarlink(void) {
32535 swig_varlinkobject *result = 0;
32536 result = PyMem_NEW(swig_varlinkobject,1);
32537 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32538 result->ob_type = &varlinktype;
32539 result->vars = 0;
32540 result->ob_refcnt = 0;
32541 Py_XINCREF((PyObject *) result);
32542 return ((PyObject*) result);
32543 }
32544
32545 static void
32546 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32547 swig_varlinkobject *v;
32548 swig_globalvar *gv;
32549 v= (swig_varlinkobject *) p;
32550 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32551 gv->name = (char *) malloc(strlen(name)+1);
32552 strcpy(gv->name,name);
32553 gv->get_attr = get_attr;
32554 gv->set_attr = set_attr;
32555 gv->next = v->vars;
32556 v->vars = gv;
32557 }
32558
32559 /* -----------------------------------------------------------------------------
32560 * constants/methods manipulation
32561 * ----------------------------------------------------------------------------- */
32562
32563 /* Install Constants */
32564 static void
32565 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32566 PyObject *obj = 0;
32567 size_t i;
32568 for (i = 0; constants[i].type; i++) {
32569 switch(constants[i].type) {
32570 case SWIG_PY_INT:
32571 obj = PyInt_FromLong(constants[i].lvalue);
32572 break;
32573 case SWIG_PY_FLOAT:
32574 obj = PyFloat_FromDouble(constants[i].dvalue);
32575 break;
32576 case SWIG_PY_STRING:
32577 if (constants[i].pvalue) {
32578 obj = PyString_FromString((char *) constants[i].pvalue);
32579 } else {
32580 Py_INCREF(Py_None);
32581 obj = Py_None;
32582 }
32583 break;
32584 case SWIG_PY_POINTER:
32585 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32586 break;
32587 case SWIG_PY_BINARY:
32588 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32589 break;
32590 default:
32591 obj = 0;
32592 break;
32593 }
32594 if (obj) {
32595 PyDict_SetItemString(d,constants[i].name,obj);
32596 Py_DECREF(obj);
32597 }
32598 }
32599 }
32600
32601 /* -----------------------------------------------------------------------------*/
32602 /* Fix SwigMethods to carry the callback ptrs when needed */
32603 /* -----------------------------------------------------------------------------*/
32604
32605 static void
32606 SWIG_Python_FixMethods(PyMethodDef *methods,
32607 swig_const_info *const_table,
32608 swig_type_info **types,
32609 swig_type_info **types_initial) {
32610 size_t i;
32611 for (i = 0; methods[i].ml_name; ++i) {
32612 char *c = methods[i].ml_doc;
32613 if (c && (c = strstr(c, "swig_ptr: "))) {
32614 int j;
32615 swig_const_info *ci = 0;
32616 char *name = c + 10;
32617 for (j = 0; const_table[j].type; j++) {
32618 if (strncmp(const_table[j].name, name,
32619 strlen(const_table[j].name)) == 0) {
32620 ci = &(const_table[j]);
32621 break;
32622 }
32623 }
32624 if (ci) {
32625 size_t shift = (ci->ptype) - types;
32626 swig_type_info *ty = types_initial[shift];
32627 size_t ldoc = (c - methods[i].ml_doc);
32628 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32629 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32630 char *buff = ndoc;
32631 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32632 strncpy(buff, methods[i].ml_doc, ldoc);
32633 buff += ldoc;
32634 strncpy(buff, "swig_ptr: ", 10);
32635 buff += 10;
32636 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32637 methods[i].ml_doc = ndoc;
32638 }
32639 }
32640 }
32641 }
32642
32643 /* -----------------------------------------------------------------------------*
32644 * Initialize type list
32645 * -----------------------------------------------------------------------------*/
32646
32647 #if PY_MAJOR_VERSION < 2
32648 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32649 is copied out of Python/modsupport.c in python version 2.3.4 */
32650 static int
32651 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32652 {
32653 PyObject *dict;
32654 if (!PyModule_Check(m)) {
32655 PyErr_SetString(PyExc_TypeError,
32656 "PyModule_AddObject() needs module as first arg");
32657 return -1;
32658 }
32659 if (!o) {
32660 PyErr_SetString(PyExc_TypeError,
32661 "PyModule_AddObject() needs non-NULL value");
32662 return -1;
32663 }
32664
32665 dict = PyModule_GetDict(m);
32666 if (dict == NULL) {
32667 /* Internal error -- modules must have a dict! */
32668 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32669 PyModule_GetName(m));
32670 return -1;
32671 }
32672 if (PyDict_SetItemString(dict, name, o))
32673 return -1;
32674 Py_DECREF(o);
32675 return 0;
32676 }
32677 #endif
32678
32679 static swig_type_info **
32680 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32681 static PyMethodDef swig_empty_runtime_method_table[] = {
32682 {
32683 NULL, NULL, 0, NULL
32684 }
32685 };/* Sentinel */
32686
32687 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32688 swig_empty_runtime_method_table);
32689 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32690 if (pointer && module) {
32691 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32692 }
32693 return type_list_handle;
32694 }
32695
32696 static swig_type_info **
32697 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32698 swig_type_info **type_pointer;
32699
32700 /* first check if module already created */
32701 type_pointer = SWIG_Python_GetTypeListHandle();
32702 if (type_pointer) {
32703 return type_pointer;
32704 } else {
32705 /* create a new module and variable */
32706 return SWIG_Python_SetTypeListHandle(type_list_handle);
32707 }
32708 }
32709
32710 #ifdef __cplusplus
32711 }
32712 #endif
32713
32714 /* -----------------------------------------------------------------------------*
32715 * Partial Init method
32716 * -----------------------------------------------------------------------------*/
32717
32718 #ifdef SWIG_LINK_RUNTIME
32719 #ifdef __cplusplus
32720 extern "C"
32721 #endif
32722 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32723 #endif
32724
32725 #ifdef __cplusplus
32726 extern "C"
32727 #endif
32728 SWIGEXPORT(void) SWIG_init(void) {
32729 static PyObject *SWIG_globals = 0;
32730 static int typeinit = 0;
32731 PyObject *m, *d;
32732 int i;
32733 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32734
32735 /* Fix SwigMethods to carry the callback ptrs when needed */
32736 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32737
32738 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32739 d = PyModule_GetDict(m);
32740
32741 if (!typeinit) {
32742 #ifdef SWIG_LINK_RUNTIME
32743 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32744 #else
32745 # ifndef SWIG_STATIC_RUNTIME
32746 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32747 # endif
32748 #endif
32749 for (i = 0; swig_types_initial[i]; i++) {
32750 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32751 }
32752 typeinit = 1;
32753 }
32754 SWIG_InstallConstants(d,swig_const_table);
32755
32756 {
32757 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32758 }
32759 {
32760 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32761 }
32762 {
32763 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32764 }
32765 {
32766 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32767 }
32768 {
32769 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32770 }
32771 {
32772 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32773 }
32774 {
32775 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32776 }
32777 {
32778 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32779 }
32780 {
32781 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32782 }
32783 {
32784 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32785 }
32786 {
32787 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32788 }
32789 {
32790 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32791 }
32792 {
32793 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32794 }
32795 {
32796 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32797 }
32798 {
32799 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32800 }
32801 {
32802 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32803 }
32804 {
32805 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32806 }
32807 {
32808 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32809 }
32810 {
32811 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32812 }
32813 {
32814 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32815 }
32816 {
32817 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32818 }
32819 {
32820 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32821 }
32822 {
32823 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32824 }
32825 {
32826 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32827 }
32828 {
32829 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32830 }
32831 {
32832 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32833 }
32834 {
32835 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32836 }
32837 {
32838 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32839 }
32840 {
32841 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32842 }
32843 {
32844 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32845 }
32846 {
32847 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32848 }
32849 {
32850 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32851 }
32852 {
32853 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32854 }
32855 {
32856 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32857 }
32858 {
32859 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32860 }
32861 {
32862 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32863 }
32864 {
32865 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32866 }
32867 {
32868 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32869 }
32870 {
32871 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32872 }
32873 {
32874 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32875 }
32876 {
32877 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32878 }
32879 {
32880 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32881 }
32882 {
32883 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32884 }
32885 {
32886 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32887 }
32888 {
32889 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32890 }
32891 {
32892 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32893 }
32894 {
32895 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32896 }
32897 {
32898 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32899 }
32900 {
32901 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32902 }
32903 {
32904 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
32905 }
32906 {
32907 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
32908 }
32909 {
32910 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
32911 }
32912 {
32913 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
32914 }
32915 {
32916 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
32917 }
32918 {
32919 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
32920 }
32921 {
32922 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
32923 }
32924 {
32925 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
32926 }
32927 {
32928 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
32929 }
32930 {
32931 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
32932 }
32933 {
32934 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
32935 }
32936 {
32937 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
32938 }
32939 {
32940 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
32941 }
32942 {
32943 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
32944 }
32945 {
32946 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
32947 }
32948 {
32949 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
32950 }
32951 {
32952 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
32953 }
32954 {
32955 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
32956 }
32957 {
32958 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
32959 }
32960 {
32961 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
32962 }
32963 {
32964 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
32965 }
32966 {
32967 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
32968 }
32969 {
32970 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
32971 }
32972 {
32973 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
32974 }
32975 {
32976 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33028 }
33029 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33030 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33031 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33032 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33033 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33034 {
33035 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33036 }
33037 {
33038 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33039 }
33040 {
33041 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33042 }
33043 {
33044 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33045 }
33046 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33047
33048 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33049
33050 {
33051 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33064 }
33065 {
33066 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33067 }
33068 {
33069 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33070 }
33071 {
33072 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33073 }
33074 {
33075 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33076 }
33077 {
33078 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33079 }
33080 {
33081 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33082 }
33083 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33084 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33085 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33086 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33087 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33088 {
33089 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33090 }
33091 {
33092 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33093 }
33094 {
33095 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33096 }
33097 {
33098 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33099 }
33100 {
33101 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33102 }
33103 {
33104 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33105 }
33106 {
33107 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33108 }
33109 {
33110 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33111 }
33112 {
33113 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33114 }
33115 {
33116 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33117 }
33118 {
33119 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33120 }
33121 {
33122 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33123 }
33124 {
33125 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33126 }
33127 {
33128 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33129 }
33130 {
33131 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33132 }
33133 {
33134 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33135 }
33136 {
33137 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33138 }
33139 {
33140 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33141 }
33142 {
33143 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33144 }
33145 {
33146 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33147 }
33148 {
33149 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33150 }
33151 {
33152 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33153 }
33154 {
33155 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33156 }
33157 {
33158 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33159 }
33160 {
33161 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33162 }
33163 {
33164 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33165 }
33166 {
33167 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33168 }
33169 {
33170 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33171 }
33172 {
33173 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33174 }
33175 {
33176 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33177 }
33178 {
33179 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33180 }
33181 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33182 {
33183 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33184 }
33185 {
33186 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33196 }
33197
33198 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33199
33200 {
33201 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33220 }
33221 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33222 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33223 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33224 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33225 {
33226 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33227 }
33228 {
33229 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33230 }
33231 {
33232 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33233 }
33234 {
33235 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33236 }
33237 {
33238 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33239 }
33240 {
33241 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33242 }
33243 {
33244 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33245 }
33246 {
33247 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33248 }
33249 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33250 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33251 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33252 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33253 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33254 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33255 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33256 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33257 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33258 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33259 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33260 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33261 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33262 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33263 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33264 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33265 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33266 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33267 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33268 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33269 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33270 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33271 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33272 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33273 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33274 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33275 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33276 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33277 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33278 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33279 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33280 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33281 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33282 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33283 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33284 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33285 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33286 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33287 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33288 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33289 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33290 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33291 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33292 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33293 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33294
33295 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33296
33297 {
33298 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33323 }
33324 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33325 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33326 {
33327 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33790 }
33791 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33792 {
33793 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33794 }
33795 {
33796 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33797 }
33798 {
33799 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33800 }
33801 {
33802 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33851 }
33852 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33853 {
33854 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33888 }
33889
33890 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33891 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33892 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33893 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33894
33895 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33896 }
33897
wxWidgets (Impactor)