]> 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
Add more art IDs
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxClipboardLocker swig_types[21]
1363 #define SWIGTYPE_p_wxIcon swig_types[22]
1364 #define SWIGTYPE_p_wxLogStderr swig_types[23]
1365 #define SWIGTYPE_p_wxLogTextCtrl swig_types[24]
1366 #define SWIGTYPE_p_wxTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxBusyCursor swig_types[26]
1368 #define SWIGTYPE_p_wxBitmapDataObject swig_types[27]
1369 #define SWIGTYPE_p_wxTextDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxPyTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxFileDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxURLDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxMetafileDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxSound swig_types[36]
1378 #define SWIGTYPE_p_wxTimerRunner swig_types[37]
1379 #define SWIGTYPE_p_wxLogWindow swig_types[38]
1380 #define SWIGTYPE_p_wxTimeSpan swig_types[39]
1381 #define SWIGTYPE_p_wxArrayString swig_types[40]
1382 #define SWIGTYPE_p_wxWindowDisabler swig_types[41]
1383 #define SWIGTYPE_p_form_ops_t swig_types[42]
1384 #define SWIGTYPE_p_wxToolTip swig_types[43]
1385 #define SWIGTYPE_p_wxDataObjectComposite swig_types[44]
1386 #define SWIGTYPE_p_wxFileConfig swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxVideoMode swig_types[47]
1389 #define SWIGTYPE_p_wxDataObjectSimple swig_types[48]
1390 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
1392 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
1393 #define SWIGTYPE_p_wxRect swig_types[52]
1394 #define SWIGTYPE_p_char swig_types[53]
1395 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[54]
1396 #define SWIGTYPE_p_wxStandardPaths swig_types[55]
1397 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1398 #define SWIGTYPE_p_wxFrame swig_types[57]
1399 #define SWIGTYPE_p_wxTimer swig_types[58]
1400 #define SWIGTYPE_p_wxPaperSize swig_types[59]
1401 #define SWIGTYPE_p_wxMimeTypesManager swig_types[60]
1402 #define SWIGTYPE_p_wxPyArtProvider swig_types[61]
1403 #define SWIGTYPE_p_wxPyTipProvider swig_types[62]
1404 #define SWIGTYPE_p_wxTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxJoystick swig_types[64]
1406 #define SWIGTYPE_p_wxSystemOptions swig_types[65]
1407 #define SWIGTYPE_p_wxPoint swig_types[66]
1408 #define SWIGTYPE_p_wxJoystickEvent swig_types[67]
1409 #define SWIGTYPE_p_wxCursor swig_types[68]
1410 #define SWIGTYPE_p_wxObject swig_types[69]
1411 #define SWIGTYPE_p_wxOutputStream swig_types[70]
1412 #define SWIGTYPE_p_wxDateTime swig_types[71]
1413 #define SWIGTYPE_p_wxPyDropSource swig_types[72]
1414 #define SWIGTYPE_p_unsigned_long swig_types[73]
1415 #define SWIGTYPE_p_wxKillError swig_types[74]
1416 #define SWIGTYPE_p_wxWindow swig_types[75]
1417 #define SWIGTYPE_p_wxString swig_types[76]
1418 #define SWIGTYPE_p_wxPyProcess swig_types[77]
1419 #define SWIGTYPE_p_wxBitmap swig_types[78]
1420 #define SWIGTYPE_p_wxConfig swig_types[79]
1421 #define SWIGTYPE_unsigned_int swig_types[80]
1422 #define SWIGTYPE_p_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_char swig_types[82]
1424 #define SWIGTYPE_p_wxChar swig_types[83]
1425 #define SWIGTYPE_p_wxBusyInfo swig_types[84]
1426 #define SWIGTYPE_p_wxPyDropTarget swig_types[85]
1427 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxProcessEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPyLog swig_types[89]
1431 #define SWIGTYPE_p_wxLogNull swig_types[90]
1432 #define SWIGTYPE_p_wxColour swig_types[91]
1433 #define SWIGTYPE_p_wxPyTimer swig_types[92]
1434 #define SWIGTYPE_p_wxConfigPathChanger swig_types[93]
1435 #define SWIGTYPE_p_wxDateSpan swig_types[94]
1436 static swig_type_info *swig_types[96];
1437
1438 /* -------- TYPES TABLE (END) -------- */
1439
1440
1441 /*-----------------------------------------------
1442 @(target):= _misc_.so
1443 ------------------------------------------------*/
1444 #define SWIG_init init_misc_
1445
1446 #define SWIG_name "_misc_"
1447
1448 #include "wx/wxPython/wxPython.h"
1449 #include "wx/wxPython/pyclasses.h"
1450 #include "wx/wxPython/pyistream.h"
1451
1452 static const wxString wxPyEmptyString(wxEmptyString);
1453
1454
1455
1456 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1457 #define SWIG_From_int PyInt_FromLong
1458 /*@@*/
1459
1460
1461 #include <limits.h>
1462
1463
1464 SWIGINTERN int
1465 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1466 const char *errmsg)
1467 {
1468 if (value < min_value) {
1469 if (errmsg) {
1470 PyErr_Format(PyExc_OverflowError,
1471 "value %ld is less than '%s' minimum %ld",
1472 value, errmsg, min_value);
1473 }
1474 return 0;
1475 } else if (value > max_value) {
1476 if (errmsg) {
1477 PyErr_Format(PyExc_OverflowError,
1478 "value %ld is greater than '%s' maximum %ld",
1479 value, errmsg, max_value);
1480 }
1481 return 0;
1482 }
1483 return 1;
1484 }
1485
1486
1487 SWIGINTERN int
1488 SWIG_AsVal_long(PyObject* obj, long* val)
1489 {
1490 if (PyNumber_Check(obj)) {
1491 if (val) *val = PyInt_AsLong(obj);
1492 return 1;
1493 }
1494 else {
1495 SWIG_type_error("number", obj);
1496 }
1497 return 0;
1498 }
1499
1500
1501 #if INT_MAX != LONG_MAX
1502 SWIGINTERN int
1503 SWIG_AsVal_int(PyObject *obj, int *val)
1504 {
1505 const char* errmsg = val ? "int" : (char*)0;
1506 long v;
1507 if (SWIG_AsVal_long(obj, &v)) {
1508 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1509 if (val) *val = (int)(v);
1510 return 1;
1511 } else {
1512 return 0;
1513 }
1514 } else {
1515 PyErr_Clear();
1516 }
1517 if (val) {
1518 SWIG_type_error(errmsg, obj);
1519 }
1520 return 0;
1521 }
1522 #else
1523 SWIGINTERNSHORT int
1524 SWIG_AsVal_int(PyObject *obj, int *val)
1525 {
1526 return SWIG_AsVal_long(obj,(long*)val);
1527 }
1528 #endif
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_As_int(PyObject* obj)
1533 {
1534 int v;
1535 if (!SWIG_AsVal_int(obj, &v)) {
1536 /*
1537 this is needed to make valgrind/purify happier.
1538 */
1539 memset((void*)&v, 0, sizeof(int));
1540 }
1541 return v;
1542 }
1543
1544
1545 SWIGINTERNSHORT int
1546 SWIG_Check_int(PyObject* obj)
1547 {
1548 return SWIG_AsVal_int(obj, (int*)0);
1549 }
1550
1551 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1552
1553 #include <wx/stockitem.h>
1554
1555 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1556 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1557 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1558
1559 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1560 #define SWIG_From_long PyInt_FromLong
1561 /*@@*/
1562
1563
1564 SWIGINTERNSHORT long
1565 SWIG_As_long(PyObject* obj)
1566 {
1567 long v;
1568 if (!SWIG_AsVal_long(obj, &v)) {
1569 /*
1570 this is needed to make valgrind/purify happier.
1571 */
1572 memset((void*)&v, 0, sizeof(long));
1573 }
1574 return v;
1575 }
1576
1577
1578 SWIGINTERNSHORT int
1579 SWIG_Check_long(PyObject* obj)
1580 {
1581 return SWIG_AsVal_long(obj, (long*)0);
1582 }
1583
1584
1585 SWIGINTERN int
1586 SWIG_AsVal_bool(PyObject *obj, bool *val)
1587 {
1588 if (obj == Py_True) {
1589 if (val) *val = true;
1590 return 1;
1591 }
1592 if (obj == Py_False) {
1593 if (val) *val = false;
1594 return 1;
1595 }
1596 int res = 0;
1597 if (SWIG_AsVal_int(obj, &res)) {
1598 if (val) *val = res ? true : false;
1599 return 1;
1600 } else {
1601 PyErr_Clear();
1602 }
1603 if (val) {
1604 SWIG_type_error("bool", obj);
1605 }
1606 return 0;
1607 }
1608
1609
1610 SWIGINTERNSHORT bool
1611 SWIG_As_bool(PyObject* obj)
1612 {
1613 bool v;
1614 if (!SWIG_AsVal_bool(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(bool));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_bool(PyObject* obj)
1626 {
1627 return SWIG_AsVal_bool(obj, (bool*)0);
1628 }
1629
1630
1631 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1632 PyObject* o2;
1633 PyObject* o3;
1634
1635 if (!target) {
1636 target = o;
1637 } else if (target == Py_None) {
1638 Py_DECREF(Py_None);
1639 target = o;
1640 } else {
1641 if (!PyTuple_Check(target)) {
1642 o2 = target;
1643 target = PyTuple_New(1);
1644 PyTuple_SetItem(target, 0, o2);
1645 }
1646 o3 = PyTuple_New(1);
1647 PyTuple_SetItem(o3, 0, o);
1648
1649 o2 = target;
1650 target = PySequence_Concat(o2, o3);
1651 Py_DECREF(o2);
1652 Py_DECREF(o3);
1653 }
1654 return target;
1655 }
1656
1657
1658
1659 long wxGetFreeMemory()
1660 { wxPyRaiseNotImplemented(); return 0; }
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void wxWakeUpMainThread() {}
1707
1708
1709 bool wxThread_IsMain() {
1710 #ifdef WXP_WITH_THREAD
1711 return wxThread::IsMain();
1712 #else
1713 return true;
1714 #endif
1715 }
1716
1717 static void wxCaret_Destroy(wxCaret *self){
1718 delete self;
1719 }
1720
1721 #include <wx/snglinst.h>
1722
1723
1724 #include <wx/tipdlg.h>
1725
1726
1727 class wxPyTipProvider : public wxTipProvider {
1728 public:
1729 wxPyTipProvider(size_t currentTip)
1730 : wxTipProvider(currentTip) {}
1731
1732 DEC_PYCALLBACK_STRING__pure(GetTip);
1733 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1734 PYPRIVATE;
1735 };
1736
1737 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1738 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1739
1740
1741 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1742
1743 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1744
1745 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1746 : wxTimer(owner, id)
1747 {
1748 if (owner == NULL) SetOwner(this);
1749 }
1750
1751
1752 void wxPyTimer::Notify() {
1753 bool found;
1754 bool blocked = wxPyBeginBlockThreads();
1755 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1756 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1757 wxPyEndBlockThreads(blocked);
1758 if (! found)
1759 wxTimer::Notify();
1760 }
1761 void wxPyTimer::base_Notify() {
1762 wxTimer::Notify();
1763 }
1764
1765
1766
1767 SWIGINTERN PyObject *
1768 SWIG_FromCharPtr(const char* cptr)
1769 {
1770 if (cptr) {
1771 size_t size = strlen(cptr);
1772 if (size > INT_MAX) {
1773 return SWIG_NewPointerObj((char*)(cptr),
1774 SWIG_TypeQuery("char *"), 0);
1775 } else {
1776 if (size != 0) {
1777 return PyString_FromStringAndSize(cptr, size);
1778 } else {
1779 return PyString_FromString(cptr);
1780 }
1781 }
1782 }
1783 Py_INCREF(Py_None);
1784 return Py_None;
1785 }
1786
1787
1788 SWIGINTERNSHORT int
1789 SWIG_CheckUnsignedLongInRange(unsigned long value,
1790 unsigned long max_value,
1791 const char *errmsg)
1792 {
1793 if (value > max_value) {
1794 if (errmsg) {
1795 PyErr_Format(PyExc_OverflowError,
1796 "value %lu is greater than '%s' minimum %lu",
1797 value, errmsg, max_value);
1798 }
1799 return 0;
1800 }
1801 return 1;
1802 }
1803
1804
1805 #if UINT_MAX != ULONG_MAX
1806 SWIGINTERN int
1807 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1808 {
1809 const char* errmsg = val ? "unsigned int" : (char*)0;
1810 unsigned long v;
1811 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1812 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1813 if (val) *val = (unsigned int)(v);
1814 return 1;
1815 }
1816 } else {
1817 PyErr_Clear();
1818 }
1819 if (val) {
1820 SWIG_type_error(errmsg, obj);
1821 }
1822 return 0;
1823 }
1824 #else
1825 SWIGINTERNSHORT unsigned int
1826 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1827 {
1828 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1829 }
1830 #endif
1831
1832
1833 SWIGINTERNSHORT unsigned int
1834 SWIG_As_unsigned_SS_int(PyObject* obj)
1835 {
1836 unsigned int v;
1837 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1838 /*
1839 this is needed to make valgrind/purify happier.
1840 */
1841 memset((void*)&v, 0, sizeof(unsigned int));
1842 }
1843 return v;
1844 }
1845
1846
1847 SWIGINTERNSHORT int
1848 SWIG_Check_unsigned_SS_int(PyObject* obj)
1849 {
1850 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1851 }
1852
1853 static wxString Log_TimeStamp(){
1854 wxString msg;
1855 wxLog::TimeStamp(&msg);
1856 return msg;
1857 }
1858 static void wxLog_Destroy(wxLog *self){ delete self; }
1859 // Make somce wrappers that double any % signs so they are 'escaped'
1860 void wxPyLogFatalError(const wxString& msg)
1861 {
1862 wxString m(msg);
1863 m.Replace(wxT("%"), wxT("%%"));
1864 wxLogFatalError(m);
1865 }
1866
1867 void wxPyLogError(const wxString& msg)
1868 {
1869 wxString m(msg);
1870 m.Replace(wxT("%"), wxT("%%"));
1871 wxLogError(m);
1872 }
1873
1874 void wxPyLogWarning(const wxString& msg)
1875 {
1876 wxString m(msg);
1877 m.Replace(wxT("%"), wxT("%%"));
1878 wxLogWarning(m);
1879 }
1880
1881 void wxPyLogMessage(const wxString& msg)
1882 {
1883 wxString m(msg);
1884 m.Replace(wxT("%"), wxT("%%"));
1885 wxLogMessage(m);
1886 }
1887
1888 void wxPyLogInfo(const wxString& msg)
1889 {
1890 wxString m(msg);
1891 m.Replace(wxT("%"), wxT("%%"));
1892 wxLogInfo(m);
1893 }
1894
1895 void wxPyLogDebug(const wxString& msg)
1896 {
1897 wxString m(msg);
1898 m.Replace(wxT("%"), wxT("%%"));
1899 wxLogDebug(m);
1900 }
1901
1902 void wxPyLogVerbose(const wxString& msg)
1903 {
1904 wxString m(msg);
1905 m.Replace(wxT("%"), wxT("%%"));
1906 wxLogVerbose(m);
1907 }
1908
1909 void wxPyLogStatus(const wxString& msg)
1910 {
1911 wxString m(msg);
1912 m.Replace(wxT("%"), wxT("%%"));
1913 wxLogStatus(m);
1914 }
1915
1916 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1917 {
1918 wxString m(msg);
1919 m.Replace(wxT("%"), wxT("%%"));
1920 wxLogStatus(pFrame, m);
1921 }
1922
1923 void wxPyLogSysError(const wxString& msg)
1924 {
1925 wxString m(msg);
1926 m.Replace(wxT("%"), wxT("%%"));
1927 wxLogSysError(m);
1928 }
1929
1930 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1931 {
1932 wxString m(msg);
1933 m.Replace(wxT("%"), wxT("%%"));
1934 wxLogGeneric(level, m);
1935 }
1936
1937 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1938 {
1939 wxString m(msg);
1940 m.Replace(wxT("%"), wxT("%%"));
1941 wxLogTrace(mask, m);
1942 }
1943
1944 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1945 {
1946 wxString m(msg);
1947 m.Replace(wxT("%"), wxT("%%"));
1948 wxLogTrace(mask, m);
1949 }
1950
1951
1952
1953 // A wxLog class that can be derived from in wxPython
1954 class wxPyLog : public wxLog {
1955 public:
1956 wxPyLog() : wxLog() {}
1957
1958 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1959 bool found;
1960 bool blocked = wxPyBeginBlockThreads();
1961 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1962 PyObject* s = wx2PyString(szString);
1963 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1964 Py_DECREF(s);
1965 }
1966 wxPyEndBlockThreads(blocked);
1967 if (! found)
1968 wxLog::DoLog(level, szString, t);
1969 }
1970
1971 virtual void DoLogString(const wxChar *szString, time_t t) {
1972 bool found;
1973 bool blocked = wxPyBeginBlockThreads();
1974 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1975 PyObject* s = wx2PyString(szString);
1976 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1977 Py_DECREF(s);
1978 }
1979 wxPyEndBlockThreads(blocked);
1980 if (! found)
1981 wxLog::DoLogString(szString, t);
1982 }
1983
1984 PYPRIVATE;
1985 };
1986
1987
1988
1989
1990 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1991
1992
1993 #include <wx/joystick.h>
1994
1995
1996 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
1997 // A C++ stub class for wxJoystick for platforms that don't have it.
1998 class wxJoystick : public wxObject {
1999 public:
2000 wxJoystick(int joystick = wxJOYSTICK1) {
2001 bool blocked = wxPyBeginBlockThreads();
2002 PyErr_SetString(PyExc_NotImplementedError,
2003 "wxJoystick is not available on this platform.");
2004 wxPyEndBlockThreads(blocked);
2005 }
2006 wxPoint GetPosition() { return wxPoint(-1,-1); }
2007 int GetZPosition() { return -1; }
2008 int GetButtonState() { return -1; }
2009 int GetPOVPosition() { return -1; }
2010 int GetPOVCTSPosition() { return -1; }
2011 int GetRudderPosition() { return -1; }
2012 int GetUPosition() { return -1; }
2013 int GetVPosition() { return -1; }
2014 int GetMovementThreshold() { return -1; }
2015 void SetMovementThreshold(int threshold) {}
2016
2017 bool IsOk(void) { return false; }
2018 int GetNumberJoysticks() { return -1; }
2019 int GetManufacturerId() { return -1; }
2020 int GetProductId() { return -1; }
2021 wxString GetProductName() { return wxEmptyString; }
2022 int GetXMin() { return -1; }
2023 int GetYMin() { return -1; }
2024 int GetZMin() { return -1; }
2025 int GetXMax() { return -1; }
2026 int GetYMax() { return -1; }
2027 int GetZMax() { return -1; }
2028 int GetNumberButtons() { return -1; }
2029 int GetNumberAxes() { return -1; }
2030 int GetMaxButtons() { return -1; }
2031 int GetMaxAxes() { return -1; }
2032 int GetPollingMin() { return -1; }
2033 int GetPollingMax() { return -1; }
2034 int GetRudderMin() { return -1; }
2035 int GetRudderMax() { return -1; }
2036 int GetUMin() { return -1; }
2037 int GetUMax() { return -1; }
2038 int GetVMin() { return -1; }
2039 int GetVMax() { return -1; }
2040
2041 bool HasRudder() { return false; }
2042 bool HasZ() { return false; }
2043 bool HasU() { return false; }
2044 bool HasV() { return false; }
2045 bool HasPOV() { return false; }
2046 bool HasPOV4Dir() { return false; }
2047 bool HasPOVCTS() { return false; }
2048
2049 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2050 bool ReleaseCapture() { return false; }
2051 };
2052 #endif
2053
2054
2055 #include <wx/sound.h>
2056
2057
2058 #if !wxUSE_SOUND
2059 // A C++ stub class for wxWave for platforms that don't have it.
2060 class wxSound : public wxObject
2061 {
2062 public:
2063 wxSound() {
2064 bool blocked = wxPyBeginBlockThreads();
2065 PyErr_SetString(PyExc_NotImplementedError,
2066 "wxSound is not available on this platform.");
2067 wxPyEndBlockThreads(blocked);
2068 }
2069 wxSound(const wxString&/*, bool*/) {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(int, const wxByte*) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081
2082 ~wxSound() {};
2083
2084 bool Create(const wxString&/*, bool*/) { return false; }
2085 bool Create(int, const wxByte*) { return false; };
2086 bool IsOk() { return false; };
2087 bool Play(unsigned) const { return false; }
2088 static bool Play(const wxString&, unsigned) { return false; }
2089 static void Stop() {}
2090 };
2091
2092 #endif
2093
2094 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2095 if (fileName.Length() == 0)
2096 return new wxSound;
2097 else
2098 return new wxSound(fileName);
2099 }
2100 static wxSound *new_wxSound(PyObject *data){
2101 unsigned char* buffer; int size;
2102 wxSound *sound = NULL;
2103
2104 bool blocked = wxPyBeginBlockThreads();
2105 if (!PyArg_Parse(data, "t#", &buffer, &size))
2106 goto done;
2107 sound = new wxSound(size, buffer);
2108 done:
2109 wxPyEndBlockThreads(blocked);
2110 return sound;
2111 }
2112 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2113 #ifndef __WXMAC__
2114 unsigned char* buffer;
2115 int size;
2116 bool rv = false;
2117
2118 bool blocked = wxPyBeginBlockThreads();
2119 if (!PyArg_Parse(data, "t#", &buffer, &size))
2120 goto done;
2121 rv = self->Create(size, buffer);
2122 done:
2123 wxPyEndBlockThreads(blocked);
2124 return rv;
2125 #else
2126 bool blocked = wxPyBeginBlockThreads();
2127 PyErr_SetString(PyExc_NotImplementedError,
2128 "Create from data is not available on this platform.");
2129 wxPyEndBlockThreads(blocked);
2130 return false;
2131 #endif
2132 }
2133
2134 #include <wx/mimetype.h>
2135
2136 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2137 wxString str;
2138 if (self->GetMimeType(&str))
2139 return wx2PyString(str);
2140 else
2141 RETURN_NONE();
2142 }
2143 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2144 wxArrayString arr;
2145 if (self->GetMimeTypes(arr))
2146 return wxArrayString2PyList_helper(arr);
2147 else
2148 RETURN_NONE();
2149 }
2150 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2151 wxArrayString arr;
2152 if (self->GetExtensions(arr))
2153 return wxArrayString2PyList_helper(arr);
2154 else
2155 RETURN_NONE();
2156 }
2157 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2158 wxIconLocation loc;
2159 if (self->GetIcon(&loc))
2160 return new wxIcon(loc);
2161 else
2162 return NULL;
2163 }
2164 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2165 wxIconLocation loc;
2166 if (self->GetIcon(&loc)) {
2167 wxString iconFile = loc.GetFileName();
2168 int iconIndex = -1;
2169
2170
2171
2172 // Make a tuple and put the values in it
2173 bool blocked = wxPyBeginBlockThreads();
2174 PyObject* tuple = PyTuple_New(3);
2175 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2176 wxT("wxIcon"), true));
2177 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2178 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2179 wxPyEndBlockThreads(blocked);
2180 return tuple;
2181 }
2182 else
2183 RETURN_NONE();
2184 }
2185 static PyObject *wxFileType_GetDescription(wxFileType *self){
2186 wxString str;
2187 if (self->GetDescription(&str))
2188 return wx2PyString(str);
2189 else
2190 RETURN_NONE();
2191 }
2192 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2193 wxString str;
2194 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2195 return wx2PyString(str);
2196 else
2197 RETURN_NONE();
2198 }
2199 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2200 wxString str;
2201 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2202 return wx2PyString(str);
2203 else
2204 RETURN_NONE();
2205 }
2206 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2207 wxArrayString verbs;
2208 wxArrayString commands;
2209 if (self->GetAllCommands(&verbs, &commands,
2210 wxFileType::MessageParameters(filename, mimetype))) {
2211 bool blocked = wxPyBeginBlockThreads();
2212 PyObject* tuple = PyTuple_New(2);
2213 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2214 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2215 wxPyEndBlockThreads(blocked);
2216 return tuple;
2217 }
2218 else
2219 RETURN_NONE();
2220 }
2221 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2222 return wxFileType::ExpandCommand(command,
2223 wxFileType::MessageParameters(filename, mimetype));
2224 }
2225 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2226 wxArrayString arr;
2227 self->EnumAllFileTypes(arr);
2228 return wxArrayString2PyList_helper(arr);
2229 }
2230
2231 #include <wx/artprov.h>
2232
2233 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2234 static const wxString wxPyART_MENU(wxART_MENU);
2235 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2236 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2237 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2238 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2239 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2240 static const wxString wxPyART_OTHER(wxART_OTHER);
2241 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2242 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2243 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2244 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2245 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2246 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2247 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2248 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2249 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2250 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2251 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2252 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2253 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2254 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2255 static const wxString wxPyART_PRINT(wxART_PRINT);
2256 static const wxString wxPyART_HELP(wxART_HELP);
2257 static const wxString wxPyART_TIP(wxART_TIP);
2258 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2259 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2260 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2261 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2262 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2263 static const wxString wxPyART_CDROM(wxART_CDROM);
2264 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2265 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2266 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2267 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2268 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2269 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2270 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2271 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2272 static const wxString wxPyART_ERROR(wxART_ERROR);
2273 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2274 static const wxString wxPyART_WARNING(wxART_WARNING);
2275 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2276 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2277 // Python aware wxArtProvider
2278 class wxPyArtProvider : public wxArtProvider {
2279 public:
2280
2281 virtual wxBitmap CreateBitmap(const wxArtID& id,
2282 const wxArtClient& client,
2283 const wxSize& size) {
2284 wxBitmap rval = wxNullBitmap;
2285 bool blocked = wxPyBeginBlockThreads();
2286 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2287 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2288 PyObject* ro;
2289 wxBitmap* ptr;
2290 PyObject* s1, *s2;
2291 s1 = wx2PyString(id);
2292 s2 = wx2PyString(client);
2293 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2294 Py_DECREF(so);
2295 Py_DECREF(s1);
2296 Py_DECREF(s2);
2297 if (ro) {
2298 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2299 rval = *ptr;
2300 Py_DECREF(ro);
2301 }
2302 }
2303 wxPyEndBlockThreads(blocked);
2304 return rval;
2305 }
2306
2307 PYPRIVATE;
2308 };
2309
2310 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2311
2312
2313
2314 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2315 PyObject* ret = PyTuple_New(3);
2316 if (ret) {
2317 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2318 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2319 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2320 }
2321 return ret;
2322 }
2323
2324 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2325 bool cont;
2326 long index = 0;
2327 wxString value;
2328
2329 cont = self->GetFirstGroup(value, index);
2330 return __EnumerationHelper(cont, value, index);
2331 }
2332 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2333 bool cont;
2334 wxString value;
2335
2336 cont = self->GetNextGroup(value, index);
2337 return __EnumerationHelper(cont, value, index);
2338 }
2339 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2340 bool cont;
2341 long index = 0;
2342 wxString value;
2343
2344 cont = self->GetFirstEntry(value, index);
2345 return __EnumerationHelper(cont, value, index);
2346 }
2347 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2348 bool cont;
2349 wxString value;
2350
2351 cont = self->GetNextEntry(value, index);
2352 return __EnumerationHelper(cont, value, index);
2353 }
2354 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2355 long rv;
2356 self->Read(key, &rv, defaultVal);
2357 return rv;
2358 }
2359
2360 SWIGINTERN int
2361 SWIG_AsVal_double(PyObject *obj, double* val)
2362 {
2363 if (PyNumber_Check(obj)) {
2364 if (val) *val = PyFloat_AsDouble(obj);
2365 return 1;
2366 }
2367 else {
2368 SWIG_type_error("number", obj);
2369 }
2370 return 0;
2371 }
2372
2373
2374 SWIGINTERNSHORT double
2375 SWIG_As_double(PyObject* obj)
2376 {
2377 double v;
2378 if (!SWIG_AsVal_double(obj, &v)) {
2379 /*
2380 this is needed to make valgrind/purify happier.
2381 */
2382 memset((void*)&v, 0, sizeof(double));
2383 }
2384 return v;
2385 }
2386
2387
2388 SWIGINTERNSHORT int
2389 SWIG_Check_double(PyObject* obj)
2390 {
2391 return SWIG_AsVal_double(obj, (double*)0);
2392 }
2393
2394 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2395 double rv;
2396 self->Read(key, &rv, defaultVal);
2397 return rv;
2398 }
2399
2400 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2401 #define SWIG_From_double PyFloat_FromDouble
2402 /*@@*/
2403
2404 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2405 bool rv;
2406 self->Read(key, &rv, defaultVal);
2407 return rv;
2408 }
2409
2410 #include <wx/datetime.h>
2411
2412 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2413 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2414
2415 #define LOCAL_TZ wxDateTime::Local
2416
2417
2418 #if UINT_MAX < LONG_MAX
2419 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2420 #define SWIG_From_unsigned_SS_int SWIG_From_long
2421 /*@@*/
2422 #else
2423 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2424 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2425 /*@@*/
2426 #endif
2427
2428 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2429 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2430 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2431 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2432 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2433 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2434 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2435 return (*self < *other);
2436 }
2437 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2438 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2439 return (*self <= *other);
2440 }
2441 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2442 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2443 return (*self > *other);
2444 }
2445 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2446 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2447 return (*self >= *other);
2448 }
2449 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2450 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2451 return (*self == *other);
2452 }
2453 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2454 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2455 return (*self != *other);
2456 }
2457 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2458 const wxChar* rv;
2459 const wxChar* _date = date;
2460 rv = self->ParseRfc822Date(_date);
2461 if (rv == NULL) return -1;
2462 return rv - _date;
2463 }
2464 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2465 const wxChar* rv;
2466 const wxChar* _date = date;
2467 rv = self->ParseFormat(_date, format, dateDef);
2468 if (rv == NULL) return -1;
2469 return rv - _date;
2470 }
2471 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2472 const wxChar* rv;
2473 const wxChar* _datetime = datetime;
2474 rv = self->ParseDateTime(_datetime);
2475 if (rv == NULL) return -1;
2476 return rv - _datetime;
2477 }
2478 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2479 const wxChar* rv;
2480 const wxChar* _date = date;
2481 rv = self->ParseDate(_date);
2482 if (rv == NULL) return -1;
2483 return rv - _date;
2484 }
2485 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2486 const wxChar* rv;
2487 const wxChar* _time = time;
2488 rv = self->ParseTime(_time);
2489 if (rv == NULL) return -1;
2490 return rv - _time;
2491 }
2492 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2493 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2494 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2495 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2496 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2497 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2498 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2499 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2500 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2501 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2502 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2503 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2504 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2505 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2506 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2507 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2508
2509 #include <wx/dataobj.h>
2510
2511 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2512 size_t count = self->GetFormatCount(dir);
2513 wxDataFormat* formats = new wxDataFormat[count];
2514 self->GetAllFormats(formats, dir);
2515
2516 bool blocked = wxPyBeginBlockThreads();
2517 PyObject* list = PyList_New(count);
2518 for (size_t i=0; i<count; i++) {
2519 wxDataFormat* format = new wxDataFormat(formats[i]);
2520 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2521 PyList_Append(list, obj);
2522 Py_DECREF(obj);
2523 }
2524 wxPyEndBlockThreads(blocked);
2525 delete [] formats;
2526 return list;
2527 }
2528 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2529 PyObject* rval = NULL;
2530 size_t size = self->GetDataSize(format);
2531 bool blocked = wxPyBeginBlockThreads();
2532 if (size) {
2533 char* buf = new char[size];
2534 if (self->GetDataHere(format, buf))
2535 rval = PyString_FromStringAndSize(buf, size);
2536 delete [] buf;
2537 }
2538 if (! rval) {
2539 rval = Py_None;
2540 Py_INCREF(rval);
2541 }
2542 wxPyEndBlockThreads(blocked);
2543 return rval;
2544 }
2545 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2546 bool rval;
2547 bool blocked = wxPyBeginBlockThreads();
2548 if (PyString_Check(data)) {
2549 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2550 }
2551 else {
2552 // raise a TypeError if not a string
2553 PyErr_SetString(PyExc_TypeError, "String expected.");
2554 rval = false;
2555 }
2556 wxPyEndBlockThreads(blocked);
2557 return rval;
2558 }
2559 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2560 PyObject* rval = NULL;
2561 size_t size = self->GetDataSize();
2562 bool blocked = wxPyBeginBlockThreads();
2563 if (size) {
2564 char* buf = new char[size];
2565 if (self->GetDataHere(buf))
2566 rval = PyString_FromStringAndSize(buf, size);
2567 delete [] buf;
2568 }
2569 if (! rval) {
2570 rval = Py_None;
2571 Py_INCREF(rval);
2572 }
2573 wxPyEndBlockThreads(blocked);
2574 return rval;
2575 }
2576 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2577 bool rval;
2578 bool blocked = wxPyBeginBlockThreads();
2579 if (PyString_Check(data)) {
2580 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2581 }
2582 else {
2583 // raise a TypeError if not a string
2584 PyErr_SetString(PyExc_TypeError, "String expected.");
2585 rval = false;
2586 }
2587 wxPyEndBlockThreads(blocked);
2588 return rval;
2589 }
2590 // Create a new class for wxPython to use
2591 class wxPyDataObjectSimple : public wxDataObjectSimple {
2592 public:
2593 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2594 : wxDataObjectSimple(format) {}
2595
2596 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2597 bool GetDataHere(void *buf) const;
2598 bool SetData(size_t len, const void *buf) const;
2599 PYPRIVATE;
2600 };
2601
2602 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2603
2604 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2605 // We need to get the data for this object and write it to buf. I think
2606 // the best way to do this for wxPython is to have the Python method
2607 // return either a string or None and then act appropriately with the
2608 // C++ version.
2609
2610 bool rval = false;
2611 bool blocked = wxPyBeginBlockThreads();
2612 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2613 PyObject* ro;
2614 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2615 if (ro) {
2616 rval = (ro != Py_None && PyString_Check(ro));
2617 if (rval)
2618 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2619 Py_DECREF(ro);
2620 }
2621 }
2622 wxPyEndBlockThreads(blocked);
2623 return rval;
2624 }
2625
2626 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2627 // For this one we simply need to make a string from buf and len
2628 // and send it to the Python method.
2629 bool rval = false;
2630 bool blocked = wxPyBeginBlockThreads();
2631 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2632 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2633 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2634 Py_DECREF(data);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 return rval;
2638 }
2639
2640 // Create a new class for wxPython to use
2641 class wxPyTextDataObject : public wxTextDataObject {
2642 public:
2643 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2644 : wxTextDataObject(text) {}
2645
2646 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2647 DEC_PYCALLBACK_STRING__const(GetText);
2648 DEC_PYCALLBACK__STRING(SetText);
2649 PYPRIVATE;
2650 };
2651
2652 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2653 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2654 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2655
2656
2657 // Create a new class for wxPython to use
2658 class wxPyBitmapDataObject : public wxBitmapDataObject {
2659 public:
2660 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2661 : wxBitmapDataObject(bitmap) {}
2662
2663 wxBitmap GetBitmap() const;
2664 void SetBitmap(const wxBitmap& bitmap);
2665 PYPRIVATE;
2666 };
2667
2668 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2669 wxBitmap* rval = &wxNullBitmap;
2670 bool blocked = wxPyBeginBlockThreads();
2671 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2672 PyObject* ro;
2673 wxBitmap* ptr;
2674 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2675 if (ro) {
2676 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2677 rval = ptr;
2678 Py_DECREF(ro);
2679 }
2680 }
2681 wxPyEndBlockThreads(blocked);
2682 return *rval;
2683 }
2684
2685 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2686 bool blocked = wxPyBeginBlockThreads();
2687 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2688 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2689 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2690 Py_DECREF(bo);
2691 }
2692 wxPyEndBlockThreads(blocked);
2693 }
2694
2695 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2696 return new wxCustomDataObject(wxDataFormat(formatName));
2697 }
2698 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2699 bool rval;
2700 bool blocked = wxPyBeginBlockThreads();
2701 if (PyString_Check(data)) {
2702 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2703 }
2704 else {
2705 // raise a TypeError if not a string
2706 PyErr_SetString(PyExc_TypeError, "String expected.");
2707 rval = false;
2708 }
2709 wxPyEndBlockThreads(blocked);
2710 return rval;
2711 }
2712 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2713 PyObject* obj;
2714 bool blocked = wxPyBeginBlockThreads();
2715 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2716 wxPyEndBlockThreads(blocked);
2717 return obj;
2718 }
2719
2720 class wxMetafileDataObject : public wxDataObjectSimple
2721 {
2722 public:
2723 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2724 };
2725
2726
2727 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2728
2729
2730 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2731 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2732 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2733 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2734 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2735
2736
2737 class wxPyTextDropTarget : public wxTextDropTarget {
2738 public:
2739 wxPyTextDropTarget() {}
2740
2741 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2742
2743 DEC_PYCALLBACK__(OnLeave);
2744 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2745 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2746 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2747 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2748
2749 PYPRIVATE;
2750 };
2751
2752 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2753 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2754 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2755 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2756 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2757 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2758
2759
2760
2761 class wxPyFileDropTarget : public wxFileDropTarget {
2762 public:
2763 wxPyFileDropTarget() {}
2764
2765 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2766
2767 DEC_PYCALLBACK__(OnLeave);
2768 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2769 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2770 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2771 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2772
2773 PYPRIVATE;
2774 };
2775
2776 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2777 const wxArrayString& filenames) {
2778 bool rval = false;
2779 bool blocked = wxPyBeginBlockThreads();
2780 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2781 PyObject* list = wxArrayString2PyList_helper(filenames);
2782 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2783 Py_DECREF(list);
2784 }
2785 wxPyEndBlockThreads(blocked);
2786 return rval;
2787 }
2788
2789
2790
2791 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2792 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2793 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2794 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2795 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2796
2797
2798
2799
2800 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2801
2802 #include <wx/display.h>
2803
2804 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2805 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2806
2807 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2808 #if !wxUSE_DISPLAY
2809 #include <wx/dynarray.h>
2810 #include <wx/vidmode.h>
2811
2812 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2813 #include "wx/arrimpl.cpp"
2814 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2815 const wxVideoMode wxDefaultVideoMode;
2816
2817 class wxDisplay
2818 {
2819 public:
2820 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2821 ~wxDisplay() {}
2822
2823 static size_t GetCount()
2824 { wxPyRaiseNotImplemented(); return 0; }
2825
2826 static int GetFromPoint(const wxPoint& pt)
2827 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2828 static int GetFromWindow(wxWindow *window)
2829 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2830
2831 virtual bool IsOk() const { return false; }
2832 virtual wxRect GetGeometry() const { wxRect r; return r; }
2833 virtual wxString GetName() const { return wxEmptyString; }
2834 bool IsPrimary() const { return false; }
2835
2836 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2837 { wxArrayVideoModes a; return a; }
2838
2839 virtual wxVideoMode GetCurrentMode() const
2840 { return wxDefaultVideoMode; }
2841
2842 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2843 { return false; }
2844
2845 void ResetMode() {}
2846 };
2847 #endif
2848
2849 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2850 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2851 PyObject* pyList = NULL;
2852 wxArrayVideoModes arr = self->GetModes(mode);
2853 bool blocked = wxPyBeginBlockThreads();
2854 pyList = PyList_New(0);
2855 for (int i=0; i < arr.GetCount(); i++) {
2856 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2857 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2858 PyList_Append(pyList, pyObj);
2859 Py_DECREF(pyObj);
2860 }
2861 wxPyEndBlockThreads(blocked);
2862 return pyList;
2863 }
2864
2865 #include <wx/stdpaths.h>
2866
2867 static wxStandardPaths *StandardPaths_Get(){
2868 return (wxStandardPaths*) &wxStandardPaths::Get();
2869 }
2870 #ifdef __cplusplus
2871 extern "C" {
2872 #endif
2873 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2874 PyObject *resultobj;
2875 wxSystemColour arg1 ;
2876 wxColour result;
2877 PyObject * obj0 = 0 ;
2878 char *kwnames[] = {
2879 (char *) "index", NULL
2880 };
2881
2882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2883 {
2884 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2885 if (SWIG_arg_fail(1)) SWIG_fail;
2886 }
2887 {
2888 if (!wxPyCheckForApp()) SWIG_fail;
2889 PyThreadState* __tstate = wxPyBeginAllowThreads();
2890 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2891
2892 wxPyEndAllowThreads(__tstate);
2893 if (PyErr_Occurred()) SWIG_fail;
2894 }
2895 {
2896 wxColour * resultptr;
2897 resultptr = new wxColour((wxColour &)(result));
2898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2899 }
2900 return resultobj;
2901 fail:
2902 return NULL;
2903 }
2904
2905
2906 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2907 PyObject *resultobj;
2908 wxSystemFont arg1 ;
2909 wxFont result;
2910 PyObject * obj0 = 0 ;
2911 char *kwnames[] = {
2912 (char *) "index", NULL
2913 };
2914
2915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2916 {
2917 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2918 if (SWIG_arg_fail(1)) SWIG_fail;
2919 }
2920 {
2921 if (!wxPyCheckForApp()) SWIG_fail;
2922 PyThreadState* __tstate = wxPyBeginAllowThreads();
2923 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2924
2925 wxPyEndAllowThreads(__tstate);
2926 if (PyErr_Occurred()) SWIG_fail;
2927 }
2928 {
2929 wxFont * resultptr;
2930 resultptr = new wxFont((wxFont &)(result));
2931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2932 }
2933 return resultobj;
2934 fail:
2935 return NULL;
2936 }
2937
2938
2939 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2940 PyObject *resultobj;
2941 wxSystemMetric arg1 ;
2942 int result;
2943 PyObject * obj0 = 0 ;
2944 char *kwnames[] = {
2945 (char *) "index", NULL
2946 };
2947
2948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2949 {
2950 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2951 if (SWIG_arg_fail(1)) SWIG_fail;
2952 }
2953 {
2954 if (!wxPyCheckForApp()) SWIG_fail;
2955 PyThreadState* __tstate = wxPyBeginAllowThreads();
2956 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2957
2958 wxPyEndAllowThreads(__tstate);
2959 if (PyErr_Occurred()) SWIG_fail;
2960 }
2961 {
2962 resultobj = SWIG_From_int((int)(result));
2963 }
2964 return resultobj;
2965 fail:
2966 return NULL;
2967 }
2968
2969
2970 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2971 PyObject *resultobj;
2972 wxSystemFeature arg1 ;
2973 bool result;
2974 PyObject * obj0 = 0 ;
2975 char *kwnames[] = {
2976 (char *) "index", NULL
2977 };
2978
2979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2980 {
2981 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2982 if (SWIG_arg_fail(1)) SWIG_fail;
2983 }
2984 {
2985 if (!wxPyCheckForApp()) SWIG_fail;
2986 PyThreadState* __tstate = wxPyBeginAllowThreads();
2987 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2988
2989 wxPyEndAllowThreads(__tstate);
2990 if (PyErr_Occurred()) SWIG_fail;
2991 }
2992 {
2993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
2994 }
2995 return resultobj;
2996 fail:
2997 return NULL;
2998 }
2999
3000
3001 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3002 PyObject *resultobj;
3003 wxSystemScreenType result;
3004 char *kwnames[] = {
3005 NULL
3006 };
3007
3008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3009 {
3010 if (!wxPyCheckForApp()) SWIG_fail;
3011 PyThreadState* __tstate = wxPyBeginAllowThreads();
3012 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3013
3014 wxPyEndAllowThreads(__tstate);
3015 if (PyErr_Occurred()) SWIG_fail;
3016 }
3017 resultobj = SWIG_From_int((result));
3018 return resultobj;
3019 fail:
3020 return NULL;
3021 }
3022
3023
3024 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3025 PyObject *resultobj;
3026 wxSystemScreenType arg1 ;
3027 PyObject * obj0 = 0 ;
3028 char *kwnames[] = {
3029 (char *) "screen", NULL
3030 };
3031
3032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3033 {
3034 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3035 if (SWIG_arg_fail(1)) SWIG_fail;
3036 }
3037 {
3038 if (!wxPyCheckForApp()) SWIG_fail;
3039 PyThreadState* __tstate = wxPyBeginAllowThreads();
3040 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3041
3042 wxPyEndAllowThreads(__tstate);
3043 if (PyErr_Occurred()) SWIG_fail;
3044 }
3045 Py_INCREF(Py_None); resultobj = Py_None;
3046 return resultobj;
3047 fail:
3048 return NULL;
3049 }
3050
3051
3052 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3053 PyObject *obj;
3054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3055 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3056 Py_INCREF(obj);
3057 return Py_BuildValue((char *)"");
3058 }
3059 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3060 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3061 return 1;
3062 }
3063
3064
3065 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3066 PyObject *pyobj;
3067
3068 {
3069 #if wxUSE_UNICODE
3070 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3071 #else
3072 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3073 #endif
3074 }
3075 return pyobj;
3076 }
3077
3078
3079 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3080 PyObject *resultobj;
3081 wxSystemOptions *result;
3082 char *kwnames[] = {
3083 NULL
3084 };
3085
3086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3087 {
3088 PyThreadState* __tstate = wxPyBeginAllowThreads();
3089 result = (wxSystemOptions *)new wxSystemOptions();
3090
3091 wxPyEndAllowThreads(__tstate);
3092 if (PyErr_Occurred()) SWIG_fail;
3093 }
3094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3095 return resultobj;
3096 fail:
3097 return NULL;
3098 }
3099
3100
3101 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3102 PyObject *resultobj;
3103 wxString *arg1 = 0 ;
3104 wxString *arg2 = 0 ;
3105 bool temp1 = false ;
3106 bool temp2 = false ;
3107 PyObject * obj0 = 0 ;
3108 PyObject * obj1 = 0 ;
3109 char *kwnames[] = {
3110 (char *) "name",(char *) "value", NULL
3111 };
3112
3113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3114 {
3115 arg1 = wxString_in_helper(obj0);
3116 if (arg1 == NULL) SWIG_fail;
3117 temp1 = true;
3118 }
3119 {
3120 arg2 = wxString_in_helper(obj1);
3121 if (arg2 == NULL) SWIG_fail;
3122 temp2 = true;
3123 }
3124 {
3125 PyThreadState* __tstate = wxPyBeginAllowThreads();
3126 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3127
3128 wxPyEndAllowThreads(__tstate);
3129 if (PyErr_Occurred()) SWIG_fail;
3130 }
3131 Py_INCREF(Py_None); resultobj = Py_None;
3132 {
3133 if (temp1)
3134 delete arg1;
3135 }
3136 {
3137 if (temp2)
3138 delete arg2;
3139 }
3140 return resultobj;
3141 fail:
3142 {
3143 if (temp1)
3144 delete arg1;
3145 }
3146 {
3147 if (temp2)
3148 delete arg2;
3149 }
3150 return NULL;
3151 }
3152
3153
3154 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3155 PyObject *resultobj;
3156 wxString *arg1 = 0 ;
3157 int arg2 ;
3158 bool temp1 = false ;
3159 PyObject * obj0 = 0 ;
3160 PyObject * obj1 = 0 ;
3161 char *kwnames[] = {
3162 (char *) "name",(char *) "value", NULL
3163 };
3164
3165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3166 {
3167 arg1 = wxString_in_helper(obj0);
3168 if (arg1 == NULL) SWIG_fail;
3169 temp1 = true;
3170 }
3171 {
3172 arg2 = (int)(SWIG_As_int(obj1));
3173 if (SWIG_arg_fail(2)) SWIG_fail;
3174 }
3175 {
3176 PyThreadState* __tstate = wxPyBeginAllowThreads();
3177 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3178
3179 wxPyEndAllowThreads(__tstate);
3180 if (PyErr_Occurred()) SWIG_fail;
3181 }
3182 Py_INCREF(Py_None); resultobj = Py_None;
3183 {
3184 if (temp1)
3185 delete arg1;
3186 }
3187 return resultobj;
3188 fail:
3189 {
3190 if (temp1)
3191 delete arg1;
3192 }
3193 return NULL;
3194 }
3195
3196
3197 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3198 PyObject *resultobj;
3199 wxString *arg1 = 0 ;
3200 wxString result;
3201 bool temp1 = false ;
3202 PyObject * obj0 = 0 ;
3203 char *kwnames[] = {
3204 (char *) "name", NULL
3205 };
3206
3207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3208 {
3209 arg1 = wxString_in_helper(obj0);
3210 if (arg1 == NULL) SWIG_fail;
3211 temp1 = true;
3212 }
3213 {
3214 PyThreadState* __tstate = wxPyBeginAllowThreads();
3215 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3216
3217 wxPyEndAllowThreads(__tstate);
3218 if (PyErr_Occurred()) SWIG_fail;
3219 }
3220 {
3221 #if wxUSE_UNICODE
3222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3223 #else
3224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3225 #endif
3226 }
3227 {
3228 if (temp1)
3229 delete arg1;
3230 }
3231 return resultobj;
3232 fail:
3233 {
3234 if (temp1)
3235 delete arg1;
3236 }
3237 return NULL;
3238 }
3239
3240
3241 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3242 PyObject *resultobj;
3243 wxString *arg1 = 0 ;
3244 int result;
3245 bool temp1 = false ;
3246 PyObject * obj0 = 0 ;
3247 char *kwnames[] = {
3248 (char *) "name", NULL
3249 };
3250
3251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3252 {
3253 arg1 = wxString_in_helper(obj0);
3254 if (arg1 == NULL) SWIG_fail;
3255 temp1 = true;
3256 }
3257 {
3258 PyThreadState* __tstate = wxPyBeginAllowThreads();
3259 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3260
3261 wxPyEndAllowThreads(__tstate);
3262 if (PyErr_Occurred()) SWIG_fail;
3263 }
3264 {
3265 resultobj = SWIG_From_int((int)(result));
3266 }
3267 {
3268 if (temp1)
3269 delete arg1;
3270 }
3271 return resultobj;
3272 fail:
3273 {
3274 if (temp1)
3275 delete arg1;
3276 }
3277 return NULL;
3278 }
3279
3280
3281 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3282 PyObject *resultobj;
3283 wxString *arg1 = 0 ;
3284 bool result;
3285 bool temp1 = false ;
3286 PyObject * obj0 = 0 ;
3287 char *kwnames[] = {
3288 (char *) "name", NULL
3289 };
3290
3291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3292 {
3293 arg1 = wxString_in_helper(obj0);
3294 if (arg1 == NULL) SWIG_fail;
3295 temp1 = true;
3296 }
3297 {
3298 PyThreadState* __tstate = wxPyBeginAllowThreads();
3299 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3300
3301 wxPyEndAllowThreads(__tstate);
3302 if (PyErr_Occurred()) SWIG_fail;
3303 }
3304 {
3305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3306 }
3307 {
3308 if (temp1)
3309 delete arg1;
3310 }
3311 return resultobj;
3312 fail:
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return NULL;
3318 }
3319
3320
3321 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3322 PyObject *obj;
3323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3324 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3325 Py_INCREF(obj);
3326 return Py_BuildValue((char *)"");
3327 }
3328 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3329 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3330 return 1;
3331 }
3332
3333
3334 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3335 PyObject *pyobj;
3336
3337 {
3338 #if wxUSE_UNICODE
3339 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3340 #else
3341 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3342 #endif
3343 }
3344 return pyobj;
3345 }
3346
3347
3348 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3349 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3350 return 1;
3351 }
3352
3353
3354 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3355 PyObject *pyobj;
3356
3357 {
3358 #if wxUSE_UNICODE
3359 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3360 #else
3361 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3362 #endif
3363 }
3364 return pyobj;
3365 }
3366
3367
3368 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3369 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3370 return 1;
3371 }
3372
3373
3374 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3375 PyObject *pyobj;
3376
3377 {
3378 #if wxUSE_UNICODE
3379 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3380 #else
3381 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3382 #endif
3383 }
3384 return pyobj;
3385 }
3386
3387
3388 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3389 PyObject *resultobj;
3390 long result;
3391 char *kwnames[] = {
3392 NULL
3393 };
3394
3395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3396 {
3397 PyThreadState* __tstate = wxPyBeginAllowThreads();
3398 result = (long)wxNewId();
3399
3400 wxPyEndAllowThreads(__tstate);
3401 if (PyErr_Occurred()) SWIG_fail;
3402 }
3403 {
3404 resultobj = SWIG_From_long((long)(result));
3405 }
3406 return resultobj;
3407 fail:
3408 return NULL;
3409 }
3410
3411
3412 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3413 PyObject *resultobj;
3414 long arg1 ;
3415 PyObject * obj0 = 0 ;
3416 char *kwnames[] = {
3417 (char *) "id", NULL
3418 };
3419
3420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3421 {
3422 arg1 = (long)(SWIG_As_long(obj0));
3423 if (SWIG_arg_fail(1)) SWIG_fail;
3424 }
3425 {
3426 PyThreadState* __tstate = wxPyBeginAllowThreads();
3427 wxRegisterId(arg1);
3428
3429 wxPyEndAllowThreads(__tstate);
3430 if (PyErr_Occurred()) SWIG_fail;
3431 }
3432 Py_INCREF(Py_None); resultobj = Py_None;
3433 return resultobj;
3434 fail:
3435 return NULL;
3436 }
3437
3438
3439 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3440 PyObject *resultobj;
3441 long result;
3442 char *kwnames[] = {
3443 NULL
3444 };
3445
3446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3447 {
3448 PyThreadState* __tstate = wxPyBeginAllowThreads();
3449 result = (long)wxGetCurrentId();
3450
3451 wxPyEndAllowThreads(__tstate);
3452 if (PyErr_Occurred()) SWIG_fail;
3453 }
3454 {
3455 resultobj = SWIG_From_long((long)(result));
3456 }
3457 return resultobj;
3458 fail:
3459 return NULL;
3460 }
3461
3462
3463 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3464 PyObject *resultobj;
3465 int arg1 ;
3466 bool result;
3467 PyObject * obj0 = 0 ;
3468 char *kwnames[] = {
3469 (char *) "id", NULL
3470 };
3471
3472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3473 {
3474 arg1 = (int)(SWIG_As_int(obj0));
3475 if (SWIG_arg_fail(1)) SWIG_fail;
3476 }
3477 {
3478 PyThreadState* __tstate = wxPyBeginAllowThreads();
3479 result = (bool)wxIsStockID(arg1);
3480
3481 wxPyEndAllowThreads(__tstate);
3482 if (PyErr_Occurred()) SWIG_fail;
3483 }
3484 {
3485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3486 }
3487 return resultobj;
3488 fail:
3489 return NULL;
3490 }
3491
3492
3493 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3494 PyObject *resultobj;
3495 int arg1 ;
3496 wxString *arg2 = 0 ;
3497 bool result;
3498 bool temp2 = false ;
3499 PyObject * obj0 = 0 ;
3500 PyObject * obj1 = 0 ;
3501 char *kwnames[] = {
3502 (char *) "id",(char *) "label", NULL
3503 };
3504
3505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3506 {
3507 arg1 = (int)(SWIG_As_int(obj0));
3508 if (SWIG_arg_fail(1)) SWIG_fail;
3509 }
3510 {
3511 arg2 = wxString_in_helper(obj1);
3512 if (arg2 == NULL) SWIG_fail;
3513 temp2 = true;
3514 }
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 {
3523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3524 }
3525 {
3526 if (temp2)
3527 delete arg2;
3528 }
3529 return resultobj;
3530 fail:
3531 {
3532 if (temp2)
3533 delete arg2;
3534 }
3535 return NULL;
3536 }
3537
3538
3539 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3540 PyObject *resultobj;
3541 int arg1 ;
3542 bool arg2 = (bool) true ;
3543 wxString arg3 = (wxString) wxPyEmptyString ;
3544 wxString result;
3545 PyObject * obj0 = 0 ;
3546 PyObject * obj1 = 0 ;
3547 PyObject * obj2 = 0 ;
3548 char *kwnames[] = {
3549 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3550 };
3551
3552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3553 {
3554 arg1 = (int)(SWIG_As_int(obj0));
3555 if (SWIG_arg_fail(1)) SWIG_fail;
3556 }
3557 if (obj1) {
3558 {
3559 arg2 = (bool)(SWIG_As_bool(obj1));
3560 if (SWIG_arg_fail(2)) SWIG_fail;
3561 }
3562 }
3563 if (obj2) {
3564 {
3565 wxString* sptr = wxString_in_helper(obj2);
3566 if (sptr == NULL) SWIG_fail;
3567 arg3 = *sptr;
3568 delete sptr;
3569 }
3570 }
3571 {
3572 PyThreadState* __tstate = wxPyBeginAllowThreads();
3573 result = wxGetStockLabel(arg1,arg2,arg3);
3574
3575 wxPyEndAllowThreads(__tstate);
3576 if (PyErr_Occurred()) SWIG_fail;
3577 }
3578 {
3579 #if wxUSE_UNICODE
3580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3581 #else
3582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3583 #endif
3584 }
3585 return resultobj;
3586 fail:
3587 return NULL;
3588 }
3589
3590
3591 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3592 PyObject *resultobj;
3593 char *kwnames[] = {
3594 NULL
3595 };
3596
3597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3598 {
3599 if (!wxPyCheckForApp()) SWIG_fail;
3600 PyThreadState* __tstate = wxPyBeginAllowThreads();
3601 wxBell();
3602
3603 wxPyEndAllowThreads(__tstate);
3604 if (PyErr_Occurred()) SWIG_fail;
3605 }
3606 Py_INCREF(Py_None); resultobj = Py_None;
3607 return resultobj;
3608 fail:
3609 return NULL;
3610 }
3611
3612
3613 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3614 PyObject *resultobj;
3615 char *kwnames[] = {
3616 NULL
3617 };
3618
3619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3620 {
3621 if (!wxPyCheckForApp()) SWIG_fail;
3622 PyThreadState* __tstate = wxPyBeginAllowThreads();
3623 wxEndBusyCursor();
3624
3625 wxPyEndAllowThreads(__tstate);
3626 if (PyErr_Occurred()) SWIG_fail;
3627 }
3628 Py_INCREF(Py_None); resultobj = Py_None;
3629 return resultobj;
3630 fail:
3631 return NULL;
3632 }
3633
3634
3635 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3636 PyObject *resultobj;
3637 bool arg1 = (bool) true ;
3638 long result;
3639 PyObject * obj0 = 0 ;
3640 char *kwnames[] = {
3641 (char *) "resetTimer", NULL
3642 };
3643
3644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3645 if (obj0) {
3646 {
3647 arg1 = (bool)(SWIG_As_bool(obj0));
3648 if (SWIG_arg_fail(1)) SWIG_fail;
3649 }
3650 }
3651 {
3652 PyThreadState* __tstate = wxPyBeginAllowThreads();
3653 result = (long)wxGetElapsedTime(arg1);
3654
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 {
3659 resultobj = SWIG_From_long((long)(result));
3660 }
3661 return resultobj;
3662 fail:
3663 return NULL;
3664 }
3665
3666
3667 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3668 PyObject *resultobj;
3669 int *arg1 = (int *) 0 ;
3670 int *arg2 = (int *) 0 ;
3671 int temp1 ;
3672 int res1 = 0 ;
3673 int temp2 ;
3674 int res2 = 0 ;
3675 char *kwnames[] = {
3676 NULL
3677 };
3678
3679 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3680 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3682 {
3683 if (!wxPyCheckForApp()) SWIG_fail;
3684 PyThreadState* __tstate = wxPyBeginAllowThreads();
3685 wxGetMousePosition(arg1,arg2);
3686
3687 wxPyEndAllowThreads(__tstate);
3688 if (PyErr_Occurred()) SWIG_fail;
3689 }
3690 Py_INCREF(Py_None); resultobj = Py_None;
3691 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3692 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3693 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3694 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3695 return resultobj;
3696 fail:
3697 return NULL;
3698 }
3699
3700
3701 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3702 PyObject *resultobj;
3703 bool result;
3704 char *kwnames[] = {
3705 NULL
3706 };
3707
3708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3709 {
3710 PyThreadState* __tstate = wxPyBeginAllowThreads();
3711 result = (bool)wxIsBusy();
3712
3713 wxPyEndAllowThreads(__tstate);
3714 if (PyErr_Occurred()) SWIG_fail;
3715 }
3716 {
3717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3718 }
3719 return resultobj;
3720 fail:
3721 return NULL;
3722 }
3723
3724
3725 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3726 PyObject *resultobj;
3727 wxString result;
3728 char *kwnames[] = {
3729 NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3733 {
3734 PyThreadState* __tstate = wxPyBeginAllowThreads();
3735 result = wxNow();
3736
3737 wxPyEndAllowThreads(__tstate);
3738 if (PyErr_Occurred()) SWIG_fail;
3739 }
3740 {
3741 #if wxUSE_UNICODE
3742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3743 #else
3744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3745 #endif
3746 }
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 wxString const &arg1_defvalue = wxPyEmptyString ;
3756 wxString *arg1 = (wxString *) &arg1_defvalue ;
3757 bool result;
3758 bool temp1 = false ;
3759 PyObject * obj0 = 0 ;
3760 char *kwnames[] = {
3761 (char *) "command", NULL
3762 };
3763
3764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3765 if (obj0) {
3766 {
3767 arg1 = wxString_in_helper(obj0);
3768 if (arg1 == NULL) SWIG_fail;
3769 temp1 = true;
3770 }
3771 }
3772 {
3773 PyThreadState* __tstate = wxPyBeginAllowThreads();
3774 result = (bool)wxShell((wxString const &)*arg1);
3775
3776 wxPyEndAllowThreads(__tstate);
3777 if (PyErr_Occurred()) SWIG_fail;
3778 }
3779 {
3780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3781 }
3782 {
3783 if (temp1)
3784 delete arg1;
3785 }
3786 return resultobj;
3787 fail:
3788 {
3789 if (temp1)
3790 delete arg1;
3791 }
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj;
3798 char *kwnames[] = {
3799 NULL
3800 };
3801
3802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3803 {
3804 PyThreadState* __tstate = wxPyBeginAllowThreads();
3805 wxStartTimer();
3806
3807 wxPyEndAllowThreads(__tstate);
3808 if (PyErr_Occurred()) SWIG_fail;
3809 }
3810 Py_INCREF(Py_None); resultobj = Py_None;
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 int *arg1 = (int *) 0 ;
3820 int *arg2 = (int *) 0 ;
3821 int result;
3822 int temp1 ;
3823 int res1 = 0 ;
3824 int temp2 ;
3825 int res2 = 0 ;
3826 char *kwnames[] = {
3827 NULL
3828 };
3829
3830 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3831 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3833 {
3834 PyThreadState* __tstate = wxPyBeginAllowThreads();
3835 result = (int)wxGetOsVersion(arg1,arg2);
3836
3837 wxPyEndAllowThreads(__tstate);
3838 if (PyErr_Occurred()) SWIG_fail;
3839 }
3840 {
3841 resultobj = SWIG_From_int((int)(result));
3842 }
3843 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3844 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3845 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3846 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3847 return resultobj;
3848 fail:
3849 return NULL;
3850 }
3851
3852
3853 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3854 PyObject *resultobj;
3855 wxString result;
3856 char *kwnames[] = {
3857 NULL
3858 };
3859
3860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3861 {
3862 PyThreadState* __tstate = wxPyBeginAllowThreads();
3863 result = wxGetOsDescription();
3864
3865 wxPyEndAllowThreads(__tstate);
3866 if (PyErr_Occurred()) SWIG_fail;
3867 }
3868 {
3869 #if wxUSE_UNICODE
3870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3871 #else
3872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3873 #endif
3874 }
3875 return resultobj;
3876 fail:
3877 return NULL;
3878 }
3879
3880
3881 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3882 PyObject *resultobj;
3883 long result;
3884 char *kwnames[] = {
3885 NULL
3886 };
3887
3888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 result = (long)wxGetFreeMemory();
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 {
3897 resultobj = SWIG_From_long((long)(result));
3898 }
3899 return resultobj;
3900 fail:
3901 return NULL;
3902 }
3903
3904
3905 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3906 PyObject *resultobj;
3907 wxShutdownFlags arg1 ;
3908 bool result;
3909 PyObject * obj0 = 0 ;
3910 char *kwnames[] = {
3911 (char *) "wFlags", NULL
3912 };
3913
3914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3915 {
3916 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3917 if (SWIG_arg_fail(1)) SWIG_fail;
3918 }
3919 {
3920 if (!wxPyCheckForApp()) SWIG_fail;
3921 PyThreadState* __tstate = wxPyBeginAllowThreads();
3922 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3923
3924 wxPyEndAllowThreads(__tstate);
3925 if (PyErr_Occurred()) SWIG_fail;
3926 }
3927 {
3928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3929 }
3930 return resultobj;
3931 fail:
3932 return NULL;
3933 }
3934
3935
3936 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 int arg1 ;
3939 PyObject * obj0 = 0 ;
3940 char *kwnames[] = {
3941 (char *) "secs", NULL
3942 };
3943
3944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3945 {
3946 arg1 = (int)(SWIG_As_int(obj0));
3947 if (SWIG_arg_fail(1)) SWIG_fail;
3948 }
3949 {
3950 PyThreadState* __tstate = wxPyBeginAllowThreads();
3951 wxSleep(arg1);
3952
3953 wxPyEndAllowThreads(__tstate);
3954 if (PyErr_Occurred()) SWIG_fail;
3955 }
3956 Py_INCREF(Py_None); resultobj = Py_None;
3957 return resultobj;
3958 fail:
3959 return NULL;
3960 }
3961
3962
3963 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3964 PyObject *resultobj;
3965 unsigned long arg1 ;
3966 PyObject * obj0 = 0 ;
3967 char *kwnames[] = {
3968 (char *) "milliseconds", NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3972 {
3973 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 }
3976 {
3977 PyThreadState* __tstate = wxPyBeginAllowThreads();
3978 wxMilliSleep(arg1);
3979
3980 wxPyEndAllowThreads(__tstate);
3981 if (PyErr_Occurred()) SWIG_fail;
3982 }
3983 Py_INCREF(Py_None); resultobj = Py_None;
3984 return resultobj;
3985 fail:
3986 return NULL;
3987 }
3988
3989
3990 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3991 PyObject *resultobj;
3992 unsigned long arg1 ;
3993 PyObject * obj0 = 0 ;
3994 char *kwnames[] = {
3995 (char *) "microseconds", NULL
3996 };
3997
3998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
3999 {
4000 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4001 if (SWIG_arg_fail(1)) SWIG_fail;
4002 }
4003 {
4004 PyThreadState* __tstate = wxPyBeginAllowThreads();
4005 wxMicroSleep(arg1);
4006
4007 wxPyEndAllowThreads(__tstate);
4008 if (PyErr_Occurred()) SWIG_fail;
4009 }
4010 Py_INCREF(Py_None); resultobj = Py_None;
4011 return resultobj;
4012 fail:
4013 return NULL;
4014 }
4015
4016
4017 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4018 PyObject *resultobj;
4019 bool arg1 ;
4020 PyObject * obj0 = 0 ;
4021 char *kwnames[] = {
4022 (char *) "enable", NULL
4023 };
4024
4025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4026 {
4027 arg1 = (bool)(SWIG_As_bool(obj0));
4028 if (SWIG_arg_fail(1)) SWIG_fail;
4029 }
4030 {
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 wxEnableTopLevelWindows(arg1);
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 Py_INCREF(Py_None); resultobj = Py_None;
4038 return resultobj;
4039 fail:
4040 return NULL;
4041 }
4042
4043
4044 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4045 PyObject *resultobj;
4046 wxString *arg1 = 0 ;
4047 wxString result;
4048 bool temp1 = false ;
4049 PyObject * obj0 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "in", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4055 {
4056 arg1 = wxString_in_helper(obj0);
4057 if (arg1 == NULL) SWIG_fail;
4058 temp1 = true;
4059 }
4060 {
4061 PyThreadState* __tstate = wxPyBeginAllowThreads();
4062 result = wxStripMenuCodes((wxString const &)*arg1);
4063
4064 wxPyEndAllowThreads(__tstate);
4065 if (PyErr_Occurred()) SWIG_fail;
4066 }
4067 {
4068 #if wxUSE_UNICODE
4069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4070 #else
4071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4072 #endif
4073 }
4074 {
4075 if (temp1)
4076 delete arg1;
4077 }
4078 return resultobj;
4079 fail:
4080 {
4081 if (temp1)
4082 delete arg1;
4083 }
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 wxString result;
4091 char *kwnames[] = {
4092 NULL
4093 };
4094
4095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4096 {
4097 PyThreadState* __tstate = wxPyBeginAllowThreads();
4098 result = wxGetEmailAddress();
4099
4100 wxPyEndAllowThreads(__tstate);
4101 if (PyErr_Occurred()) SWIG_fail;
4102 }
4103 {
4104 #if wxUSE_UNICODE
4105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4106 #else
4107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4108 #endif
4109 }
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj;
4118 wxString result;
4119 char *kwnames[] = {
4120 NULL
4121 };
4122
4123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4124 {
4125 PyThreadState* __tstate = wxPyBeginAllowThreads();
4126 result = wxGetHostName();
4127
4128 wxPyEndAllowThreads(__tstate);
4129 if (PyErr_Occurred()) SWIG_fail;
4130 }
4131 {
4132 #if wxUSE_UNICODE
4133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4134 #else
4135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4136 #endif
4137 }
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj;
4146 wxString result;
4147 char *kwnames[] = {
4148 NULL
4149 };
4150
4151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4152 {
4153 PyThreadState* __tstate = wxPyBeginAllowThreads();
4154 result = wxGetFullHostName();
4155
4156 wxPyEndAllowThreads(__tstate);
4157 if (PyErr_Occurred()) SWIG_fail;
4158 }
4159 {
4160 #if wxUSE_UNICODE
4161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4162 #else
4163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4164 #endif
4165 }
4166 return resultobj;
4167 fail:
4168 return NULL;
4169 }
4170
4171
4172 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4173 PyObject *resultobj;
4174 wxString result;
4175 char *kwnames[] = {
4176 NULL
4177 };
4178
4179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4180 {
4181 PyThreadState* __tstate = wxPyBeginAllowThreads();
4182 result = wxGetUserId();
4183
4184 wxPyEndAllowThreads(__tstate);
4185 if (PyErr_Occurred()) SWIG_fail;
4186 }
4187 {
4188 #if wxUSE_UNICODE
4189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4190 #else
4191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4192 #endif
4193 }
4194 return resultobj;
4195 fail:
4196 return NULL;
4197 }
4198
4199
4200 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4201 PyObject *resultobj;
4202 wxString result;
4203 char *kwnames[] = {
4204 NULL
4205 };
4206
4207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4208 {
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = wxGetUserName();
4211
4212 wxPyEndAllowThreads(__tstate);
4213 if (PyErr_Occurred()) SWIG_fail;
4214 }
4215 {
4216 #if wxUSE_UNICODE
4217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4218 #else
4219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4220 #endif
4221 }
4222 return resultobj;
4223 fail:
4224 return NULL;
4225 }
4226
4227
4228 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4229 PyObject *resultobj;
4230 wxString result;
4231 char *kwnames[] = {
4232 NULL
4233 };
4234
4235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4236 {
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 result = wxGetHomeDir();
4239
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 {
4244 #if wxUSE_UNICODE
4245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4246 #else
4247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4248 #endif
4249 }
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj;
4258 wxString const &arg1_defvalue = wxPyEmptyString ;
4259 wxString *arg1 = (wxString *) &arg1_defvalue ;
4260 wxString result;
4261 bool temp1 = false ;
4262 PyObject * obj0 = 0 ;
4263 char *kwnames[] = {
4264 (char *) "user", NULL
4265 };
4266
4267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4268 if (obj0) {
4269 {
4270 arg1 = wxString_in_helper(obj0);
4271 if (arg1 == NULL) SWIG_fail;
4272 temp1 = true;
4273 }
4274 }
4275 {
4276 PyThreadState* __tstate = wxPyBeginAllowThreads();
4277 result = wxGetUserHome((wxString const &)*arg1);
4278
4279 wxPyEndAllowThreads(__tstate);
4280 if (PyErr_Occurred()) SWIG_fail;
4281 }
4282 {
4283 #if wxUSE_UNICODE
4284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4285 #else
4286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4287 #endif
4288 }
4289 {
4290 if (temp1)
4291 delete arg1;
4292 }
4293 return resultobj;
4294 fail:
4295 {
4296 if (temp1)
4297 delete arg1;
4298 }
4299 return NULL;
4300 }
4301
4302
4303 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4304 PyObject *resultobj;
4305 unsigned long result;
4306 char *kwnames[] = {
4307 NULL
4308 };
4309
4310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4311 {
4312 PyThreadState* __tstate = wxPyBeginAllowThreads();
4313 result = (unsigned long)wxGetProcessId();
4314
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 {
4319 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4320 }
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 char *kwnames[] = {
4330 NULL
4331 };
4332
4333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4334 {
4335 PyThreadState* __tstate = wxPyBeginAllowThreads();
4336 wxTrap();
4337
4338 wxPyEndAllowThreads(__tstate);
4339 if (PyErr_Occurred()) SWIG_fail;
4340 }
4341 Py_INCREF(Py_None); resultobj = Py_None;
4342 return resultobj;
4343 fail:
4344 return NULL;
4345 }
4346
4347
4348 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4349 PyObject *resultobj;
4350 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4351 wxString *arg1 = (wxString *) &arg1_defvalue ;
4352 wxString const &arg2_defvalue = wxPyEmptyString ;
4353 wxString *arg2 = (wxString *) &arg2_defvalue ;
4354 wxString const &arg3_defvalue = wxPyEmptyString ;
4355 wxString *arg3 = (wxString *) &arg3_defvalue ;
4356 wxString const &arg4_defvalue = wxPyEmptyString ;
4357 wxString *arg4 = (wxString *) &arg4_defvalue ;
4358 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4359 wxString *arg5 = (wxString *) &arg5_defvalue ;
4360 int arg6 = (int) 0 ;
4361 wxWindow *arg7 = (wxWindow *) NULL ;
4362 int arg8 = (int) -1 ;
4363 int arg9 = (int) -1 ;
4364 wxString result;
4365 bool temp1 = false ;
4366 bool temp2 = false ;
4367 bool temp3 = false ;
4368 bool temp4 = false ;
4369 bool temp5 = false ;
4370 PyObject * obj0 = 0 ;
4371 PyObject * obj1 = 0 ;
4372 PyObject * obj2 = 0 ;
4373 PyObject * obj3 = 0 ;
4374 PyObject * obj4 = 0 ;
4375 PyObject * obj5 = 0 ;
4376 PyObject * obj6 = 0 ;
4377 PyObject * obj7 = 0 ;
4378 PyObject * obj8 = 0 ;
4379 char *kwnames[] = {
4380 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4381 };
4382
4383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4384 if (obj0) {
4385 {
4386 arg1 = wxString_in_helper(obj0);
4387 if (arg1 == NULL) SWIG_fail;
4388 temp1 = true;
4389 }
4390 }
4391 if (obj1) {
4392 {
4393 arg2 = wxString_in_helper(obj1);
4394 if (arg2 == NULL) SWIG_fail;
4395 temp2 = true;
4396 }
4397 }
4398 if (obj2) {
4399 {
4400 arg3 = wxString_in_helper(obj2);
4401 if (arg3 == NULL) SWIG_fail;
4402 temp3 = true;
4403 }
4404 }
4405 if (obj3) {
4406 {
4407 arg4 = wxString_in_helper(obj3);
4408 if (arg4 == NULL) SWIG_fail;
4409 temp4 = true;
4410 }
4411 }
4412 if (obj4) {
4413 {
4414 arg5 = wxString_in_helper(obj4);
4415 if (arg5 == NULL) SWIG_fail;
4416 temp5 = true;
4417 }
4418 }
4419 if (obj5) {
4420 {
4421 arg6 = (int)(SWIG_As_int(obj5));
4422 if (SWIG_arg_fail(6)) SWIG_fail;
4423 }
4424 }
4425 if (obj6) {
4426 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4427 if (SWIG_arg_fail(7)) SWIG_fail;
4428 }
4429 if (obj7) {
4430 {
4431 arg8 = (int)(SWIG_As_int(obj7));
4432 if (SWIG_arg_fail(8)) SWIG_fail;
4433 }
4434 }
4435 if (obj8) {
4436 {
4437 arg9 = (int)(SWIG_As_int(obj8));
4438 if (SWIG_arg_fail(9)) SWIG_fail;
4439 }
4440 }
4441 {
4442 if (!wxPyCheckForApp()) SWIG_fail;
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4445
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 {
4450 #if wxUSE_UNICODE
4451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4452 #else
4453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4454 #endif
4455 }
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 {
4461 if (temp2)
4462 delete arg2;
4463 }
4464 {
4465 if (temp3)
4466 delete arg3;
4467 }
4468 {
4469 if (temp4)
4470 delete arg4;
4471 }
4472 {
4473 if (temp5)
4474 delete arg5;
4475 }
4476 return resultobj;
4477 fail:
4478 {
4479 if (temp1)
4480 delete arg1;
4481 }
4482 {
4483 if (temp2)
4484 delete arg2;
4485 }
4486 {
4487 if (temp3)
4488 delete arg3;
4489 }
4490 {
4491 if (temp4)
4492 delete arg4;
4493 }
4494 {
4495 if (temp5)
4496 delete arg5;
4497 }
4498 return NULL;
4499 }
4500
4501
4502 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj;
4504 wxString *arg1 = 0 ;
4505 wxString *arg2 = 0 ;
4506 wxString const &arg3_defvalue = wxPyEmptyString ;
4507 wxString *arg3 = (wxString *) &arg3_defvalue ;
4508 wxWindow *arg4 = (wxWindow *) NULL ;
4509 wxString result;
4510 bool temp1 = false ;
4511 bool temp2 = false ;
4512 bool temp3 = false ;
4513 PyObject * obj0 = 0 ;
4514 PyObject * obj1 = 0 ;
4515 PyObject * obj2 = 0 ;
4516 PyObject * obj3 = 0 ;
4517 char *kwnames[] = {
4518 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4519 };
4520
4521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4522 {
4523 arg1 = wxString_in_helper(obj0);
4524 if (arg1 == NULL) SWIG_fail;
4525 temp1 = true;
4526 }
4527 {
4528 arg2 = wxString_in_helper(obj1);
4529 if (arg2 == NULL) SWIG_fail;
4530 temp2 = true;
4531 }
4532 if (obj2) {
4533 {
4534 arg3 = wxString_in_helper(obj2);
4535 if (arg3 == NULL) SWIG_fail;
4536 temp3 = true;
4537 }
4538 }
4539 if (obj3) {
4540 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4541 if (SWIG_arg_fail(4)) SWIG_fail;
4542 }
4543 {
4544 if (!wxPyCheckForApp()) SWIG_fail;
4545 PyThreadState* __tstate = wxPyBeginAllowThreads();
4546 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4547
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 #if wxUSE_UNICODE
4553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4554 #else
4555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4556 #endif
4557 }
4558 {
4559 if (temp1)
4560 delete arg1;
4561 }
4562 {
4563 if (temp2)
4564 delete arg2;
4565 }
4566 {
4567 if (temp3)
4568 delete arg3;
4569 }
4570 return resultobj;
4571 fail:
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 {
4577 if (temp2)
4578 delete arg2;
4579 }
4580 {
4581 if (temp3)
4582 delete arg3;
4583 }
4584 return NULL;
4585 }
4586
4587
4588 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj;
4590 wxString *arg1 = 0 ;
4591 wxString *arg2 = 0 ;
4592 wxString const &arg3_defvalue = wxPyEmptyString ;
4593 wxString *arg3 = (wxString *) &arg3_defvalue ;
4594 wxWindow *arg4 = (wxWindow *) NULL ;
4595 wxString result;
4596 bool temp1 = false ;
4597 bool temp2 = false ;
4598 bool temp3 = false ;
4599 PyObject * obj0 = 0 ;
4600 PyObject * obj1 = 0 ;
4601 PyObject * obj2 = 0 ;
4602 PyObject * obj3 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4608 {
4609 arg1 = wxString_in_helper(obj0);
4610 if (arg1 == NULL) SWIG_fail;
4611 temp1 = true;
4612 }
4613 {
4614 arg2 = wxString_in_helper(obj1);
4615 if (arg2 == NULL) SWIG_fail;
4616 temp2 = true;
4617 }
4618 if (obj2) {
4619 {
4620 arg3 = wxString_in_helper(obj2);
4621 if (arg3 == NULL) SWIG_fail;
4622 temp3 = true;
4623 }
4624 }
4625 if (obj3) {
4626 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4627 if (SWIG_arg_fail(4)) SWIG_fail;
4628 }
4629 {
4630 if (!wxPyCheckForApp()) SWIG_fail;
4631 PyThreadState* __tstate = wxPyBeginAllowThreads();
4632 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4633
4634 wxPyEndAllowThreads(__tstate);
4635 if (PyErr_Occurred()) SWIG_fail;
4636 }
4637 {
4638 #if wxUSE_UNICODE
4639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4640 #else
4641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4642 #endif
4643 }
4644 {
4645 if (temp1)
4646 delete arg1;
4647 }
4648 {
4649 if (temp2)
4650 delete arg2;
4651 }
4652 {
4653 if (temp3)
4654 delete arg3;
4655 }
4656 return resultobj;
4657 fail:
4658 {
4659 if (temp1)
4660 delete arg1;
4661 }
4662 {
4663 if (temp2)
4664 delete arg2;
4665 }
4666 {
4667 if (temp3)
4668 delete arg3;
4669 }
4670 return NULL;
4671 }
4672
4673
4674 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj;
4676 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4677 wxString *arg1 = (wxString *) &arg1_defvalue ;
4678 wxString const &arg2_defvalue = wxPyEmptyString ;
4679 wxString *arg2 = (wxString *) &arg2_defvalue ;
4680 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4681 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4682 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4683 wxWindow *arg5 = (wxWindow *) NULL ;
4684 wxString result;
4685 bool temp1 = false ;
4686 bool temp2 = false ;
4687 wxPoint temp4 ;
4688 PyObject * obj0 = 0 ;
4689 PyObject * obj1 = 0 ;
4690 PyObject * obj2 = 0 ;
4691 PyObject * obj3 = 0 ;
4692 PyObject * obj4 = 0 ;
4693 char *kwnames[] = {
4694 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4695 };
4696
4697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4698 if (obj0) {
4699 {
4700 arg1 = wxString_in_helper(obj0);
4701 if (arg1 == NULL) SWIG_fail;
4702 temp1 = true;
4703 }
4704 }
4705 if (obj1) {
4706 {
4707 arg2 = wxString_in_helper(obj1);
4708 if (arg2 == NULL) SWIG_fail;
4709 temp2 = true;
4710 }
4711 }
4712 if (obj2) {
4713 {
4714 arg3 = (long)(SWIG_As_long(obj2));
4715 if (SWIG_arg_fail(3)) SWIG_fail;
4716 }
4717 }
4718 if (obj3) {
4719 {
4720 arg4 = &temp4;
4721 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4722 }
4723 }
4724 if (obj4) {
4725 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4726 if (SWIG_arg_fail(5)) SWIG_fail;
4727 }
4728 {
4729 if (!wxPyCheckForApp()) SWIG_fail;
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4732
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 {
4737 #if wxUSE_UNICODE
4738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4739 #else
4740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4741 #endif
4742 }
4743 {
4744 if (temp1)
4745 delete arg1;
4746 }
4747 {
4748 if (temp2)
4749 delete arg2;
4750 }
4751 return resultobj;
4752 fail:
4753 {
4754 if (temp1)
4755 delete arg1;
4756 }
4757 {
4758 if (temp2)
4759 delete arg2;
4760 }
4761 return NULL;
4762 }
4763
4764
4765 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4766 PyObject *resultobj;
4767 wxString *arg1 = 0 ;
4768 wxString const &arg2_defvalue = wxPyEmptyString ;
4769 wxString *arg2 = (wxString *) &arg2_defvalue ;
4770 wxString const &arg3_defvalue = wxPyEmptyString ;
4771 wxString *arg3 = (wxString *) &arg3_defvalue ;
4772 wxWindow *arg4 = (wxWindow *) NULL ;
4773 int arg5 = (int) -1 ;
4774 int arg6 = (int) -1 ;
4775 bool arg7 = (bool) true ;
4776 wxString result;
4777 bool temp1 = false ;
4778 bool temp2 = false ;
4779 bool temp3 = false ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 PyObject * obj2 = 0 ;
4783 PyObject * obj3 = 0 ;
4784 PyObject * obj4 = 0 ;
4785 PyObject * obj5 = 0 ;
4786 PyObject * obj6 = 0 ;
4787 char *kwnames[] = {
4788 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4789 };
4790
4791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4792 {
4793 arg1 = wxString_in_helper(obj0);
4794 if (arg1 == NULL) SWIG_fail;
4795 temp1 = true;
4796 }
4797 if (obj1) {
4798 {
4799 arg2 = wxString_in_helper(obj1);
4800 if (arg2 == NULL) SWIG_fail;
4801 temp2 = true;
4802 }
4803 }
4804 if (obj2) {
4805 {
4806 arg3 = wxString_in_helper(obj2);
4807 if (arg3 == NULL) SWIG_fail;
4808 temp3 = true;
4809 }
4810 }
4811 if (obj3) {
4812 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4813 if (SWIG_arg_fail(4)) SWIG_fail;
4814 }
4815 if (obj4) {
4816 {
4817 arg5 = (int)(SWIG_As_int(obj4));
4818 if (SWIG_arg_fail(5)) SWIG_fail;
4819 }
4820 }
4821 if (obj5) {
4822 {
4823 arg6 = (int)(SWIG_As_int(obj5));
4824 if (SWIG_arg_fail(6)) SWIG_fail;
4825 }
4826 }
4827 if (obj6) {
4828 {
4829 arg7 = (bool)(SWIG_As_bool(obj6));
4830 if (SWIG_arg_fail(7)) SWIG_fail;
4831 }
4832 }
4833 {
4834 if (!wxPyCheckForApp()) SWIG_fail;
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4837
4838 wxPyEndAllowThreads(__tstate);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 {
4842 #if wxUSE_UNICODE
4843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4844 #else
4845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4846 #endif
4847 }
4848 {
4849 if (temp1)
4850 delete arg1;
4851 }
4852 {
4853 if (temp2)
4854 delete arg2;
4855 }
4856 {
4857 if (temp3)
4858 delete arg3;
4859 }
4860 return resultobj;
4861 fail:
4862 {
4863 if (temp1)
4864 delete arg1;
4865 }
4866 {
4867 if (temp2)
4868 delete arg2;
4869 }
4870 {
4871 if (temp3)
4872 delete arg3;
4873 }
4874 return NULL;
4875 }
4876
4877
4878 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj;
4880 wxString *arg1 = 0 ;
4881 wxString const &arg2_defvalue = wxPyEmptyString ;
4882 wxString *arg2 = (wxString *) &arg2_defvalue ;
4883 wxString const &arg3_defvalue = wxPyEmptyString ;
4884 wxString *arg3 = (wxString *) &arg3_defvalue ;
4885 wxWindow *arg4 = (wxWindow *) NULL ;
4886 wxString result;
4887 bool temp1 = false ;
4888 bool temp2 = false ;
4889 bool temp3 = false ;
4890 PyObject * obj0 = 0 ;
4891 PyObject * obj1 = 0 ;
4892 PyObject * obj2 = 0 ;
4893 PyObject * obj3 = 0 ;
4894 char *kwnames[] = {
4895 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4896 };
4897
4898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4899 {
4900 arg1 = wxString_in_helper(obj0);
4901 if (arg1 == NULL) SWIG_fail;
4902 temp1 = true;
4903 }
4904 if (obj1) {
4905 {
4906 arg2 = wxString_in_helper(obj1);
4907 if (arg2 == NULL) SWIG_fail;
4908 temp2 = true;
4909 }
4910 }
4911 if (obj2) {
4912 {
4913 arg3 = wxString_in_helper(obj2);
4914 if (arg3 == NULL) SWIG_fail;
4915 temp3 = true;
4916 }
4917 }
4918 if (obj3) {
4919 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4920 if (SWIG_arg_fail(4)) SWIG_fail;
4921 }
4922 {
4923 if (!wxPyCheckForApp()) SWIG_fail;
4924 PyThreadState* __tstate = wxPyBeginAllowThreads();
4925 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4926
4927 wxPyEndAllowThreads(__tstate);
4928 if (PyErr_Occurred()) SWIG_fail;
4929 }
4930 {
4931 #if wxUSE_UNICODE
4932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4933 #else
4934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4935 #endif
4936 }
4937 {
4938 if (temp1)
4939 delete arg1;
4940 }
4941 {
4942 if (temp2)
4943 delete arg2;
4944 }
4945 {
4946 if (temp3)
4947 delete arg3;
4948 }
4949 return resultobj;
4950 fail:
4951 {
4952 if (temp1)
4953 delete arg1;
4954 }
4955 {
4956 if (temp2)
4957 delete arg2;
4958 }
4959 {
4960 if (temp3)
4961 delete arg3;
4962 }
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj;
4969 wxString *arg1 = 0 ;
4970 wxString *arg2 = 0 ;
4971 int arg3 ;
4972 wxString *arg4 = (wxString *) 0 ;
4973 wxWindow *arg5 = (wxWindow *) NULL ;
4974 int arg6 = (int) -1 ;
4975 int arg7 = (int) -1 ;
4976 bool arg8 = (bool) true ;
4977 int arg9 = (int) 150 ;
4978 int arg10 = (int) 200 ;
4979 wxString result;
4980 bool temp1 = false ;
4981 bool temp2 = false ;
4982 PyObject * obj0 = 0 ;
4983 PyObject * obj1 = 0 ;
4984 PyObject * obj2 = 0 ;
4985 PyObject * obj3 = 0 ;
4986 PyObject * obj4 = 0 ;
4987 PyObject * obj5 = 0 ;
4988 PyObject * obj6 = 0 ;
4989 PyObject * obj7 = 0 ;
4990 PyObject * obj8 = 0 ;
4991 char *kwnames[] = {
4992 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4993 };
4994
4995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4996 {
4997 arg1 = wxString_in_helper(obj0);
4998 if (arg1 == NULL) SWIG_fail;
4999 temp1 = true;
5000 }
5001 {
5002 arg2 = wxString_in_helper(obj1);
5003 if (arg2 == NULL) SWIG_fail;
5004 temp2 = true;
5005 }
5006 {
5007 arg3 = PyList_Size(obj2);
5008 arg4 = wxString_LIST_helper(obj2);
5009 if (arg4 == NULL) SWIG_fail;
5010 }
5011 if (obj3) {
5012 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5013 if (SWIG_arg_fail(5)) SWIG_fail;
5014 }
5015 if (obj4) {
5016 {
5017 arg6 = (int)(SWIG_As_int(obj4));
5018 if (SWIG_arg_fail(6)) SWIG_fail;
5019 }
5020 }
5021 if (obj5) {
5022 {
5023 arg7 = (int)(SWIG_As_int(obj5));
5024 if (SWIG_arg_fail(7)) SWIG_fail;
5025 }
5026 }
5027 if (obj6) {
5028 {
5029 arg8 = (bool)(SWIG_As_bool(obj6));
5030 if (SWIG_arg_fail(8)) SWIG_fail;
5031 }
5032 }
5033 if (obj7) {
5034 {
5035 arg9 = (int)(SWIG_As_int(obj7));
5036 if (SWIG_arg_fail(9)) SWIG_fail;
5037 }
5038 }
5039 if (obj8) {
5040 {
5041 arg10 = (int)(SWIG_As_int(obj8));
5042 if (SWIG_arg_fail(10)) SWIG_fail;
5043 }
5044 }
5045 {
5046 if (!wxPyCheckForApp()) SWIG_fail;
5047 PyThreadState* __tstate = wxPyBeginAllowThreads();
5048 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5049
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 {
5054 #if wxUSE_UNICODE
5055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5056 #else
5057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5058 #endif
5059 }
5060 {
5061 if (temp1)
5062 delete arg1;
5063 }
5064 {
5065 if (temp2)
5066 delete arg2;
5067 }
5068 {
5069 if (arg4) delete [] arg4;
5070 }
5071 return resultobj;
5072 fail:
5073 {
5074 if (temp1)
5075 delete arg1;
5076 }
5077 {
5078 if (temp2)
5079 delete arg2;
5080 }
5081 {
5082 if (arg4) delete [] arg4;
5083 }
5084 return NULL;
5085 }
5086
5087
5088 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5089 PyObject *resultobj;
5090 wxString *arg1 = 0 ;
5091 wxString *arg2 = 0 ;
5092 int arg3 ;
5093 wxString *arg4 = (wxString *) 0 ;
5094 wxWindow *arg5 = (wxWindow *) NULL ;
5095 int arg6 = (int) -1 ;
5096 int arg7 = (int) -1 ;
5097 bool arg8 = (bool) true ;
5098 int arg9 = (int) 150 ;
5099 int arg10 = (int) 200 ;
5100 int result;
5101 bool temp1 = false ;
5102 bool temp2 = false ;
5103 PyObject * obj0 = 0 ;
5104 PyObject * obj1 = 0 ;
5105 PyObject * obj2 = 0 ;
5106 PyObject * obj3 = 0 ;
5107 PyObject * obj4 = 0 ;
5108 PyObject * obj5 = 0 ;
5109 PyObject * obj6 = 0 ;
5110 PyObject * obj7 = 0 ;
5111 PyObject * obj8 = 0 ;
5112 char *kwnames[] = {
5113 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5114 };
5115
5116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5117 {
5118 arg1 = wxString_in_helper(obj0);
5119 if (arg1 == NULL) SWIG_fail;
5120 temp1 = true;
5121 }
5122 {
5123 arg2 = wxString_in_helper(obj1);
5124 if (arg2 == NULL) SWIG_fail;
5125 temp2 = true;
5126 }
5127 {
5128 arg3 = PyList_Size(obj2);
5129 arg4 = wxString_LIST_helper(obj2);
5130 if (arg4 == NULL) SWIG_fail;
5131 }
5132 if (obj3) {
5133 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5134 if (SWIG_arg_fail(5)) SWIG_fail;
5135 }
5136 if (obj4) {
5137 {
5138 arg6 = (int)(SWIG_As_int(obj4));
5139 if (SWIG_arg_fail(6)) SWIG_fail;
5140 }
5141 }
5142 if (obj5) {
5143 {
5144 arg7 = (int)(SWIG_As_int(obj5));
5145 if (SWIG_arg_fail(7)) SWIG_fail;
5146 }
5147 }
5148 if (obj6) {
5149 {
5150 arg8 = (bool)(SWIG_As_bool(obj6));
5151 if (SWIG_arg_fail(8)) SWIG_fail;
5152 }
5153 }
5154 if (obj7) {
5155 {
5156 arg9 = (int)(SWIG_As_int(obj7));
5157 if (SWIG_arg_fail(9)) SWIG_fail;
5158 }
5159 }
5160 if (obj8) {
5161 {
5162 arg10 = (int)(SWIG_As_int(obj8));
5163 if (SWIG_arg_fail(10)) SWIG_fail;
5164 }
5165 }
5166 {
5167 if (!wxPyCheckForApp()) SWIG_fail;
5168 PyThreadState* __tstate = wxPyBeginAllowThreads();
5169 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5170
5171 wxPyEndAllowThreads(__tstate);
5172 if (PyErr_Occurred()) SWIG_fail;
5173 }
5174 {
5175 resultobj = SWIG_From_int((int)(result));
5176 }
5177 {
5178 if (temp1)
5179 delete arg1;
5180 }
5181 {
5182 if (temp2)
5183 delete arg2;
5184 }
5185 {
5186 if (arg4) delete [] arg4;
5187 }
5188 return resultobj;
5189 fail:
5190 {
5191 if (temp1)
5192 delete arg1;
5193 }
5194 {
5195 if (temp2)
5196 delete arg2;
5197 }
5198 {
5199 if (arg4) delete [] arg4;
5200 }
5201 return NULL;
5202 }
5203
5204
5205 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5206 PyObject *resultobj;
5207 wxString *arg1 = 0 ;
5208 wxString const &arg2_defvalue = wxPyEmptyString ;
5209 wxString *arg2 = (wxString *) &arg2_defvalue ;
5210 int arg3 = (int) wxOK|wxCENTRE ;
5211 wxWindow *arg4 = (wxWindow *) NULL ;
5212 int arg5 = (int) -1 ;
5213 int arg6 = (int) -1 ;
5214 int result;
5215 bool temp1 = false ;
5216 bool temp2 = false ;
5217 PyObject * obj0 = 0 ;
5218 PyObject * obj1 = 0 ;
5219 PyObject * obj2 = 0 ;
5220 PyObject * obj3 = 0 ;
5221 PyObject * obj4 = 0 ;
5222 PyObject * obj5 = 0 ;
5223 char *kwnames[] = {
5224 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5225 };
5226
5227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5228 {
5229 arg1 = wxString_in_helper(obj0);
5230 if (arg1 == NULL) SWIG_fail;
5231 temp1 = true;
5232 }
5233 if (obj1) {
5234 {
5235 arg2 = wxString_in_helper(obj1);
5236 if (arg2 == NULL) SWIG_fail;
5237 temp2 = true;
5238 }
5239 }
5240 if (obj2) {
5241 {
5242 arg3 = (int)(SWIG_As_int(obj2));
5243 if (SWIG_arg_fail(3)) SWIG_fail;
5244 }
5245 }
5246 if (obj3) {
5247 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5248 if (SWIG_arg_fail(4)) SWIG_fail;
5249 }
5250 if (obj4) {
5251 {
5252 arg5 = (int)(SWIG_As_int(obj4));
5253 if (SWIG_arg_fail(5)) SWIG_fail;
5254 }
5255 }
5256 if (obj5) {
5257 {
5258 arg6 = (int)(SWIG_As_int(obj5));
5259 if (SWIG_arg_fail(6)) SWIG_fail;
5260 }
5261 }
5262 {
5263 if (!wxPyCheckForApp()) SWIG_fail;
5264 PyThreadState* __tstate = wxPyBeginAllowThreads();
5265 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5266
5267 wxPyEndAllowThreads(__tstate);
5268 if (PyErr_Occurred()) SWIG_fail;
5269 }
5270 {
5271 resultobj = SWIG_From_int((int)(result));
5272 }
5273 {
5274 if (temp1)
5275 delete arg1;
5276 }
5277 {
5278 if (temp2)
5279 delete arg2;
5280 }
5281 return resultobj;
5282 fail:
5283 {
5284 if (temp1)
5285 delete arg1;
5286 }
5287 {
5288 if (temp2)
5289 delete arg2;
5290 }
5291 return NULL;
5292 }
5293
5294
5295 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5296 PyObject *resultobj;
5297 wxString *arg1 = 0 ;
5298 wxString *arg2 = 0 ;
5299 wxString *arg3 = 0 ;
5300 long arg4 ;
5301 long arg5 = (long) 0 ;
5302 long arg6 = (long) 100 ;
5303 wxWindow *arg7 = (wxWindow *) NULL ;
5304 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5305 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5306 long result;
5307 bool temp1 = false ;
5308 bool temp2 = false ;
5309 bool temp3 = false ;
5310 wxPoint temp8 ;
5311 PyObject * obj0 = 0 ;
5312 PyObject * obj1 = 0 ;
5313 PyObject * obj2 = 0 ;
5314 PyObject * obj3 = 0 ;
5315 PyObject * obj4 = 0 ;
5316 PyObject * obj5 = 0 ;
5317 PyObject * obj6 = 0 ;
5318 PyObject * obj7 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5324 {
5325 arg1 = wxString_in_helper(obj0);
5326 if (arg1 == NULL) SWIG_fail;
5327 temp1 = true;
5328 }
5329 {
5330 arg2 = wxString_in_helper(obj1);
5331 if (arg2 == NULL) SWIG_fail;
5332 temp2 = true;
5333 }
5334 {
5335 arg3 = wxString_in_helper(obj2);
5336 if (arg3 == NULL) SWIG_fail;
5337 temp3 = true;
5338 }
5339 {
5340 arg4 = (long)(SWIG_As_long(obj3));
5341 if (SWIG_arg_fail(4)) SWIG_fail;
5342 }
5343 if (obj4) {
5344 {
5345 arg5 = (long)(SWIG_As_long(obj4));
5346 if (SWIG_arg_fail(5)) SWIG_fail;
5347 }
5348 }
5349 if (obj5) {
5350 {
5351 arg6 = (long)(SWIG_As_long(obj5));
5352 if (SWIG_arg_fail(6)) SWIG_fail;
5353 }
5354 }
5355 if (obj6) {
5356 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5357 if (SWIG_arg_fail(7)) SWIG_fail;
5358 }
5359 if (obj7) {
5360 {
5361 arg8 = &temp8;
5362 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5363 }
5364 }
5365 {
5366 if (!wxPyCheckForApp()) SWIG_fail;
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 {
5374 resultobj = SWIG_From_long((long)(result));
5375 }
5376 {
5377 if (temp1)
5378 delete arg1;
5379 }
5380 {
5381 if (temp2)
5382 delete arg2;
5383 }
5384 {
5385 if (temp3)
5386 delete arg3;
5387 }
5388 return resultobj;
5389 fail:
5390 {
5391 if (temp1)
5392 delete arg1;
5393 }
5394 {
5395 if (temp2)
5396 delete arg2;
5397 }
5398 {
5399 if (temp3)
5400 delete arg3;
5401 }
5402 return NULL;
5403 }
5404
5405
5406 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj;
5408 bool result;
5409 char *kwnames[] = {
5410 NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5414 {
5415 if (!wxPyCheckForApp()) SWIG_fail;
5416 PyThreadState* __tstate = wxPyBeginAllowThreads();
5417 result = (bool)wxColourDisplay();
5418
5419 wxPyEndAllowThreads(__tstate);
5420 if (PyErr_Occurred()) SWIG_fail;
5421 }
5422 {
5423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5424 }
5425 return resultobj;
5426 fail:
5427 return NULL;
5428 }
5429
5430
5431 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5432 PyObject *resultobj;
5433 int result;
5434 char *kwnames[] = {
5435 NULL
5436 };
5437
5438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5439 {
5440 if (!wxPyCheckForApp()) SWIG_fail;
5441 PyThreadState* __tstate = wxPyBeginAllowThreads();
5442 result = (int)wxDisplayDepth();
5443
5444 wxPyEndAllowThreads(__tstate);
5445 if (PyErr_Occurred()) SWIG_fail;
5446 }
5447 {
5448 resultobj = SWIG_From_int((int)(result));
5449 }
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5457 PyObject *resultobj;
5458 int result;
5459 char *kwnames[] = {
5460 NULL
5461 };
5462
5463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5464 {
5465 if (!wxPyCheckForApp()) SWIG_fail;
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (int)wxGetDisplayDepth();
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 {
5473 resultobj = SWIG_From_int((int)(result));
5474 }
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj;
5483 int *arg1 = (int *) 0 ;
5484 int *arg2 = (int *) 0 ;
5485 int temp1 ;
5486 int res1 = 0 ;
5487 int temp2 ;
5488 int res2 = 0 ;
5489 char *kwnames[] = {
5490 NULL
5491 };
5492
5493 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5494 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5496 {
5497 if (!wxPyCheckForApp()) SWIG_fail;
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 wxDisplaySize(arg1,arg2);
5500
5501 wxPyEndAllowThreads(__tstate);
5502 if (PyErr_Occurred()) SWIG_fail;
5503 }
5504 Py_INCREF(Py_None); resultobj = Py_None;
5505 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5506 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5507 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5508 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 wxSize result;
5518 char *kwnames[] = {
5519 NULL
5520 };
5521
5522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5523 {
5524 if (!wxPyCheckForApp()) SWIG_fail;
5525 PyThreadState* __tstate = wxPyBeginAllowThreads();
5526 result = wxGetDisplaySize();
5527
5528 wxPyEndAllowThreads(__tstate);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 wxSize * resultptr;
5533 resultptr = new wxSize((wxSize &)(result));
5534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5535 }
5536 return resultobj;
5537 fail:
5538 return NULL;
5539 }
5540
5541
5542 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5543 PyObject *resultobj;
5544 int *arg1 = (int *) 0 ;
5545 int *arg2 = (int *) 0 ;
5546 int temp1 ;
5547 int res1 = 0 ;
5548 int temp2 ;
5549 int res2 = 0 ;
5550 char *kwnames[] = {
5551 NULL
5552 };
5553
5554 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5555 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5557 {
5558 if (!wxPyCheckForApp()) SWIG_fail;
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 wxDisplaySizeMM(arg1,arg2);
5561
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 Py_INCREF(Py_None); resultobj = Py_None;
5566 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5567 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5568 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5569 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5577 PyObject *resultobj;
5578 wxSize result;
5579 char *kwnames[] = {
5580 NULL
5581 };
5582
5583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5584 {
5585 if (!wxPyCheckForApp()) SWIG_fail;
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = wxGetDisplaySizeMM();
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 {
5593 wxSize * resultptr;
5594 resultptr = new wxSize((wxSize &)(result));
5595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5596 }
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj;
5605 int *arg1 = (int *) 0 ;
5606 int *arg2 = (int *) 0 ;
5607 int *arg3 = (int *) 0 ;
5608 int *arg4 = (int *) 0 ;
5609 int temp1 ;
5610 int res1 = 0 ;
5611 int temp2 ;
5612 int res2 = 0 ;
5613 int temp3 ;
5614 int res3 = 0 ;
5615 int temp4 ;
5616 int res4 = 0 ;
5617 char *kwnames[] = {
5618 NULL
5619 };
5620
5621 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5622 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5623 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5624 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5626 {
5627 if (!wxPyCheckForApp()) SWIG_fail;
5628 PyThreadState* __tstate = wxPyBeginAllowThreads();
5629 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5630
5631 wxPyEndAllowThreads(__tstate);
5632 if (PyErr_Occurred()) SWIG_fail;
5633 }
5634 Py_INCREF(Py_None); resultobj = Py_None;
5635 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5636 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5637 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5638 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5639 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5640 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5641 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5642 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5643 return resultobj;
5644 fail:
5645 return NULL;
5646 }
5647
5648
5649 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5650 PyObject *resultobj;
5651 wxRect result;
5652 char *kwnames[] = {
5653 NULL
5654 };
5655
5656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5657 {
5658 if (!wxPyCheckForApp()) SWIG_fail;
5659 PyThreadState* __tstate = wxPyBeginAllowThreads();
5660 result = wxGetClientDisplayRect();
5661
5662 wxPyEndAllowThreads(__tstate);
5663 if (PyErr_Occurred()) SWIG_fail;
5664 }
5665 {
5666 wxRect * resultptr;
5667 resultptr = new wxRect((wxRect &)(result));
5668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5669 }
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj;
5678 wxCursor *arg1 = 0 ;
5679 PyObject * obj0 = 0 ;
5680 char *kwnames[] = {
5681 (char *) "cursor", NULL
5682 };
5683
5684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5685 {
5686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5687 if (SWIG_arg_fail(1)) SWIG_fail;
5688 if (arg1 == NULL) {
5689 SWIG_null_ref("wxCursor");
5690 }
5691 if (SWIG_arg_fail(1)) SWIG_fail;
5692 }
5693 {
5694 if (!wxPyCheckForApp()) SWIG_fail;
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 wxSetCursor(*arg1);
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 Py_INCREF(Py_None); resultobj = Py_None;
5702 return resultobj;
5703 fail:
5704 return NULL;
5705 }
5706
5707
5708 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5709 PyObject *resultobj;
5710 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5711 PyObject * obj0 = 0 ;
5712 char *kwnames[] = {
5713 (char *) "cursor", NULL
5714 };
5715
5716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5717 if (obj0) {
5718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5719 if (SWIG_arg_fail(1)) SWIG_fail;
5720 }
5721 {
5722 if (!wxPyCheckForApp()) SWIG_fail;
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 wxBeginBusyCursor(arg1);
5725
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 Py_INCREF(Py_None); resultobj = Py_None;
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj;
5738 wxWindow *result;
5739 char *kwnames[] = {
5740 NULL
5741 };
5742
5743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5744 {
5745 if (!wxPyCheckForApp()) SWIG_fail;
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 result = (wxWindow *)wxGetActiveWindow();
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 {
5753 resultobj = wxPyMake_wxObject(result, 0);
5754 }
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj;
5763 wxPoint *arg1 = 0 ;
5764 wxWindow *result;
5765 wxPoint temp1 ;
5766 PyObject * obj0 = 0 ;
5767 char *kwnames[] = {
5768 (char *) "pt", NULL
5769 };
5770
5771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5772 {
5773 arg1 = &temp1;
5774 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5775 }
5776 {
5777 if (!wxPyCheckForApp()) SWIG_fail;
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5780
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 {
5785 resultobj = wxPyMake_wxObject(result, 0);
5786 }
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5794 PyObject *resultobj;
5795 wxPoint *arg1 = 0 ;
5796 wxWindow *result;
5797 wxPoint temp1 ;
5798 PyObject * obj0 = 0 ;
5799 char *kwnames[] = {
5800 (char *) "pt", NULL
5801 };
5802
5803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5804 {
5805 arg1 = &temp1;
5806 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5807 }
5808 {
5809 if (!wxPyCheckForApp()) SWIG_fail;
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 {
5817 resultobj = wxPyMake_wxObject(result, 0);
5818 }
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj;
5827 wxWindow *arg1 = (wxWindow *) 0 ;
5828 wxWindow *result;
5829 PyObject * obj0 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "win", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5836 if (SWIG_arg_fail(1)) SWIG_fail;
5837 {
5838 if (!wxPyCheckForApp()) SWIG_fail;
5839 PyThreadState* __tstate = wxPyBeginAllowThreads();
5840 result = (wxWindow *)wxGetTopLevelParent(arg1);
5841
5842 wxPyEndAllowThreads(__tstate);
5843 if (PyErr_Occurred()) SWIG_fail;
5844 }
5845 {
5846 resultobj = wxPyMake_wxObject(result, 0);
5847 }
5848 return resultobj;
5849 fail:
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxKeyCode arg1 ;
5857 bool result;
5858 PyObject * obj0 = 0 ;
5859 char *kwnames[] = {
5860 (char *) "key", NULL
5861 };
5862
5863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5864 {
5865 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5866 if (SWIG_arg_fail(1)) SWIG_fail;
5867 }
5868 {
5869 if (!wxPyCheckForApp()) SWIG_fail;
5870 PyThreadState* __tstate = wxPyBeginAllowThreads();
5871 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5872
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 {
5877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5878 }
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj;
5887 char *kwnames[] = {
5888 NULL
5889 };
5890
5891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5892 {
5893 if (!wxPyCheckForApp()) SWIG_fail;
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 wxWakeUpMainThread();
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 Py_INCREF(Py_None); resultobj = Py_None;
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj;
5909 char *kwnames[] = {
5910 NULL
5911 };
5912
5913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5914 {
5915 if (!wxPyCheckForApp()) SWIG_fail;
5916 PyThreadState* __tstate = wxPyBeginAllowThreads();
5917 wxMutexGuiEnter();
5918
5919 wxPyEndAllowThreads(__tstate);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 Py_INCREF(Py_None); resultobj = Py_None;
5923 return resultobj;
5924 fail:
5925 return NULL;
5926 }
5927
5928
5929 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj;
5931 char *kwnames[] = {
5932 NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 wxMutexGuiLeave();
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 Py_INCREF(Py_None); resultobj = Py_None;
5945 return resultobj;
5946 fail:
5947 return NULL;
5948 }
5949
5950
5951 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5952 PyObject *resultobj;
5953 wxMutexGuiLocker *result;
5954 char *kwnames[] = {
5955 NULL
5956 };
5957
5958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5959 {
5960 if (!wxPyCheckForApp()) SWIG_fail;
5961 PyThreadState* __tstate = wxPyBeginAllowThreads();
5962 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5963
5964 wxPyEndAllowThreads(__tstate);
5965 if (PyErr_Occurred()) SWIG_fail;
5966 }
5967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5977 PyObject * obj0 = 0 ;
5978 char *kwnames[] = {
5979 (char *) "self", NULL
5980 };
5981
5982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5984 if (SWIG_arg_fail(1)) SWIG_fail;
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 delete arg1;
5988
5989 wxPyEndAllowThreads(__tstate);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 Py_INCREF(Py_None); resultobj = Py_None;
5993 return resultobj;
5994 fail:
5995 return NULL;
5996 }
5997
5998
5999 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6000 PyObject *obj;
6001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6002 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6003 Py_INCREF(obj);
6004 return Py_BuildValue((char *)"");
6005 }
6006 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj;
6008 bool result;
6009 char *kwnames[] = {
6010 NULL
6011 };
6012
6013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6014 {
6015 PyThreadState* __tstate = wxPyBeginAllowThreads();
6016 result = (bool)wxThread_IsMain();
6017
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 {
6022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6023 }
6024 return resultobj;
6025 fail:
6026 return NULL;
6027 }
6028
6029
6030 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6031 PyObject *resultobj;
6032 wxString *arg1 = 0 ;
6033 wxToolTip *result;
6034 bool temp1 = false ;
6035 PyObject * obj0 = 0 ;
6036 char *kwnames[] = {
6037 (char *) "tip", NULL
6038 };
6039
6040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6041 {
6042 arg1 = wxString_in_helper(obj0);
6043 if (arg1 == NULL) SWIG_fail;
6044 temp1 = true;
6045 }
6046 {
6047 if (!wxPyCheckForApp()) SWIG_fail;
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 {
6055 resultobj = wxPyMake_wxObject(result, 1);
6056 }
6057 {
6058 if (temp1)
6059 delete arg1;
6060 }
6061 return resultobj;
6062 fail:
6063 {
6064 if (temp1)
6065 delete arg1;
6066 }
6067 return NULL;
6068 }
6069
6070
6071 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj;
6073 wxToolTip *arg1 = (wxToolTip *) 0 ;
6074 wxString *arg2 = 0 ;
6075 bool temp2 = false ;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 char *kwnames[] = {
6079 (char *) "self",(char *) "tip", NULL
6080 };
6081
6082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6084 if (SWIG_arg_fail(1)) SWIG_fail;
6085 {
6086 arg2 = wxString_in_helper(obj1);
6087 if (arg2 == NULL) SWIG_fail;
6088 temp2 = true;
6089 }
6090 {
6091 PyThreadState* __tstate = wxPyBeginAllowThreads();
6092 (arg1)->SetTip((wxString const &)*arg2);
6093
6094 wxPyEndAllowThreads(__tstate);
6095 if (PyErr_Occurred()) SWIG_fail;
6096 }
6097 Py_INCREF(Py_None); resultobj = Py_None;
6098 {
6099 if (temp2)
6100 delete arg2;
6101 }
6102 return resultobj;
6103 fail:
6104 {
6105 if (temp2)
6106 delete arg2;
6107 }
6108 return NULL;
6109 }
6110
6111
6112 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6113 PyObject *resultobj;
6114 wxToolTip *arg1 = (wxToolTip *) 0 ;
6115 wxString result;
6116 PyObject * obj0 = 0 ;
6117 char *kwnames[] = {
6118 (char *) "self", NULL
6119 };
6120
6121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6123 if (SWIG_arg_fail(1)) SWIG_fail;
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (arg1)->GetTip();
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 #if wxUSE_UNICODE
6133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6134 #else
6135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6136 #endif
6137 }
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6145 PyObject *resultobj;
6146 wxToolTip *arg1 = (wxToolTip *) 0 ;
6147 wxWindow *result;
6148 PyObject * obj0 = 0 ;
6149 char *kwnames[] = {
6150 (char *) "self", NULL
6151 };
6152
6153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6155 if (SWIG_arg_fail(1)) SWIG_fail;
6156 {
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (wxWindow *)(arg1)->GetWindow();
6159
6160 wxPyEndAllowThreads(__tstate);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 {
6164 resultobj = wxPyMake_wxObject(result, 0);
6165 }
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj;
6174 bool arg1 ;
6175 PyObject * obj0 = 0 ;
6176 char *kwnames[] = {
6177 (char *) "flag", NULL
6178 };
6179
6180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6181 {
6182 arg1 = (bool)(SWIG_As_bool(obj0));
6183 if (SWIG_arg_fail(1)) SWIG_fail;
6184 }
6185 {
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 wxToolTip::Enable(arg1);
6188
6189 wxPyEndAllowThreads(__tstate);
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 Py_INCREF(Py_None); resultobj = Py_None;
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6200 PyObject *resultobj;
6201 long arg1 ;
6202 PyObject * obj0 = 0 ;
6203 char *kwnames[] = {
6204 (char *) "milliseconds", NULL
6205 };
6206
6207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6208 {
6209 arg1 = (long)(SWIG_As_long(obj0));
6210 if (SWIG_arg_fail(1)) SWIG_fail;
6211 }
6212 {
6213 PyThreadState* __tstate = wxPyBeginAllowThreads();
6214 wxToolTip::SetDelay(arg1);
6215
6216 wxPyEndAllowThreads(__tstate);
6217 if (PyErr_Occurred()) SWIG_fail;
6218 }
6219 Py_INCREF(Py_None); resultobj = Py_None;
6220 return resultobj;
6221 fail:
6222 return NULL;
6223 }
6224
6225
6226 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6227 PyObject *obj;
6228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6229 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6230 Py_INCREF(obj);
6231 return Py_BuildValue((char *)"");
6232 }
6233 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6234 PyObject *resultobj;
6235 wxWindow *arg1 = (wxWindow *) 0 ;
6236 wxSize *arg2 = 0 ;
6237 wxCaret *result;
6238 wxSize temp2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char *kwnames[] = {
6242 (char *) "window",(char *) "size", NULL
6243 };
6244
6245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6247 if (SWIG_arg_fail(1)) SWIG_fail;
6248 {
6249 arg2 = &temp2;
6250 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6251 }
6252 {
6253 if (!wxPyCheckForApp()) SWIG_fail;
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6256
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj;
6269 wxCaret *arg1 = (wxCaret *) 0 ;
6270 PyObject * obj0 = 0 ;
6271 char *kwnames[] = {
6272 (char *) "self", NULL
6273 };
6274
6275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6277 if (SWIG_arg_fail(1)) SWIG_fail;
6278 {
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 wxCaret_Destroy(arg1);
6281
6282 wxPyEndAllowThreads(__tstate);
6283 if (PyErr_Occurred()) SWIG_fail;
6284 }
6285 Py_INCREF(Py_None); resultobj = Py_None;
6286 return resultobj;
6287 fail:
6288 return NULL;
6289 }
6290
6291
6292 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6293 PyObject *resultobj;
6294 wxCaret *arg1 = (wxCaret *) 0 ;
6295 bool result;
6296 PyObject * obj0 = 0 ;
6297 char *kwnames[] = {
6298 (char *) "self", NULL
6299 };
6300
6301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6303 if (SWIG_arg_fail(1)) SWIG_fail;
6304 {
6305 PyThreadState* __tstate = wxPyBeginAllowThreads();
6306 result = (bool)(arg1)->IsOk();
6307
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 {
6312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6313 }
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj;
6322 wxCaret *arg1 = (wxCaret *) 0 ;
6323 bool result;
6324 PyObject * obj0 = 0 ;
6325 char *kwnames[] = {
6326 (char *) "self", NULL
6327 };
6328
6329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6331 if (SWIG_arg_fail(1)) SWIG_fail;
6332 {
6333 PyThreadState* __tstate = wxPyBeginAllowThreads();
6334 result = (bool)(arg1)->IsVisible();
6335
6336 wxPyEndAllowThreads(__tstate);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 {
6340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6341 }
6342 return resultobj;
6343 fail:
6344 return NULL;
6345 }
6346
6347
6348 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6349 PyObject *resultobj;
6350 wxCaret *arg1 = (wxCaret *) 0 ;
6351 wxPoint result;
6352 PyObject * obj0 = 0 ;
6353 char *kwnames[] = {
6354 (char *) "self", NULL
6355 };
6356
6357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6359 if (SWIG_arg_fail(1)) SWIG_fail;
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = (arg1)->GetPosition();
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 {
6368 wxPoint * resultptr;
6369 resultptr = new wxPoint((wxPoint &)(result));
6370 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6371 }
6372 return resultobj;
6373 fail:
6374 return NULL;
6375 }
6376
6377
6378 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6379 PyObject *resultobj;
6380 wxCaret *arg1 = (wxCaret *) 0 ;
6381 int *arg2 = (int *) 0 ;
6382 int *arg3 = (int *) 0 ;
6383 int temp2 ;
6384 int res2 = 0 ;
6385 int temp3 ;
6386 int res3 = 0 ;
6387 PyObject * obj0 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self", NULL
6390 };
6391
6392 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6393 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6396 if (SWIG_arg_fail(1)) SWIG_fail;
6397 {
6398 PyThreadState* __tstate = wxPyBeginAllowThreads();
6399 (arg1)->GetPosition(arg2,arg3);
6400
6401 wxPyEndAllowThreads(__tstate);
6402 if (PyErr_Occurred()) SWIG_fail;
6403 }
6404 Py_INCREF(Py_None); resultobj = Py_None;
6405 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6406 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6407 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6408 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj;
6417 wxCaret *arg1 = (wxCaret *) 0 ;
6418 wxSize result;
6419 PyObject * obj0 = 0 ;
6420 char *kwnames[] = {
6421 (char *) "self", NULL
6422 };
6423
6424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6426 if (SWIG_arg_fail(1)) SWIG_fail;
6427 {
6428 PyThreadState* __tstate = wxPyBeginAllowThreads();
6429 result = (arg1)->GetSize();
6430
6431 wxPyEndAllowThreads(__tstate);
6432 if (PyErr_Occurred()) SWIG_fail;
6433 }
6434 {
6435 wxSize * resultptr;
6436 resultptr = new wxSize((wxSize &)(result));
6437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6438 }
6439 return resultobj;
6440 fail:
6441 return NULL;
6442 }
6443
6444
6445 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6446 PyObject *resultobj;
6447 wxCaret *arg1 = (wxCaret *) 0 ;
6448 int *arg2 = (int *) 0 ;
6449 int *arg3 = (int *) 0 ;
6450 int temp2 ;
6451 int res2 = 0 ;
6452 int temp3 ;
6453 int res3 = 0 ;
6454 PyObject * obj0 = 0 ;
6455 char *kwnames[] = {
6456 (char *) "self", NULL
6457 };
6458
6459 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6460 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6463 if (SWIG_arg_fail(1)) SWIG_fail;
6464 {
6465 PyThreadState* __tstate = wxPyBeginAllowThreads();
6466 (arg1)->GetSize(arg2,arg3);
6467
6468 wxPyEndAllowThreads(__tstate);
6469 if (PyErr_Occurred()) SWIG_fail;
6470 }
6471 Py_INCREF(Py_None); resultobj = Py_None;
6472 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6473 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6474 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6475 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6476 return resultobj;
6477 fail:
6478 return NULL;
6479 }
6480
6481
6482 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6483 PyObject *resultobj;
6484 wxCaret *arg1 = (wxCaret *) 0 ;
6485 wxWindow *result;
6486 PyObject * obj0 = 0 ;
6487 char *kwnames[] = {
6488 (char *) "self", NULL
6489 };
6490
6491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6493 if (SWIG_arg_fail(1)) SWIG_fail;
6494 {
6495 PyThreadState* __tstate = wxPyBeginAllowThreads();
6496 result = (wxWindow *)(arg1)->GetWindow();
6497
6498 wxPyEndAllowThreads(__tstate);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 {
6502 resultobj = wxPyMake_wxObject(result, 0);
6503 }
6504 return resultobj;
6505 fail:
6506 return NULL;
6507 }
6508
6509
6510 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6511 PyObject *resultobj;
6512 wxCaret *arg1 = (wxCaret *) 0 ;
6513 int arg2 ;
6514 int arg3 ;
6515 PyObject * obj0 = 0 ;
6516 PyObject * obj1 = 0 ;
6517 PyObject * obj2 = 0 ;
6518 char *kwnames[] = {
6519 (char *) "self",(char *) "x",(char *) "y", NULL
6520 };
6521
6522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6524 if (SWIG_arg_fail(1)) SWIG_fail;
6525 {
6526 arg2 = (int)(SWIG_As_int(obj1));
6527 if (SWIG_arg_fail(2)) SWIG_fail;
6528 }
6529 {
6530 arg3 = (int)(SWIG_As_int(obj2));
6531 if (SWIG_arg_fail(3)) SWIG_fail;
6532 }
6533 {
6534 PyThreadState* __tstate = wxPyBeginAllowThreads();
6535 (arg1)->Move(arg2,arg3);
6536
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 Py_INCREF(Py_None); resultobj = Py_None;
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj;
6549 wxCaret *arg1 = (wxCaret *) 0 ;
6550 wxPoint *arg2 = 0 ;
6551 wxPoint temp2 ;
6552 PyObject * obj0 = 0 ;
6553 PyObject * obj1 = 0 ;
6554 char *kwnames[] = {
6555 (char *) "self",(char *) "pt", NULL
6556 };
6557
6558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6560 if (SWIG_arg_fail(1)) SWIG_fail;
6561 {
6562 arg2 = &temp2;
6563 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6564 }
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 (arg1)->Move((wxPoint const &)*arg2);
6568
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 Py_INCREF(Py_None); resultobj = Py_None;
6573 return resultobj;
6574 fail:
6575 return NULL;
6576 }
6577
6578
6579 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6580 PyObject *resultobj;
6581 wxCaret *arg1 = (wxCaret *) 0 ;
6582 int arg2 ;
6583 int arg3 ;
6584 PyObject * obj0 = 0 ;
6585 PyObject * obj1 = 0 ;
6586 PyObject * obj2 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self",(char *) "width",(char *) "height", NULL
6589 };
6590
6591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6593 if (SWIG_arg_fail(1)) SWIG_fail;
6594 {
6595 arg2 = (int)(SWIG_As_int(obj1));
6596 if (SWIG_arg_fail(2)) SWIG_fail;
6597 }
6598 {
6599 arg3 = (int)(SWIG_As_int(obj2));
6600 if (SWIG_arg_fail(3)) SWIG_fail;
6601 }
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 (arg1)->SetSize(arg2,arg3);
6605
6606 wxPyEndAllowThreads(__tstate);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 Py_INCREF(Py_None); resultobj = Py_None;
6610 return resultobj;
6611 fail:
6612 return NULL;
6613 }
6614
6615
6616 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6617 PyObject *resultobj;
6618 wxCaret *arg1 = (wxCaret *) 0 ;
6619 wxSize *arg2 = 0 ;
6620 wxSize temp2 ;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 char *kwnames[] = {
6624 (char *) "self",(char *) "size", NULL
6625 };
6626
6627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6629 if (SWIG_arg_fail(1)) SWIG_fail;
6630 {
6631 arg2 = &temp2;
6632 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6633 }
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 (arg1)->SetSize((wxSize const &)*arg2);
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 Py_INCREF(Py_None); resultobj = Py_None;
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj;
6650 wxCaret *arg1 = (wxCaret *) 0 ;
6651 int arg2 = (int) true ;
6652 PyObject * obj0 = 0 ;
6653 PyObject * obj1 = 0 ;
6654 char *kwnames[] = {
6655 (char *) "self",(char *) "show", NULL
6656 };
6657
6658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6660 if (SWIG_arg_fail(1)) SWIG_fail;
6661 if (obj1) {
6662 {
6663 arg2 = (int)(SWIG_As_int(obj1));
6664 if (SWIG_arg_fail(2)) SWIG_fail;
6665 }
6666 }
6667 {
6668 PyThreadState* __tstate = wxPyBeginAllowThreads();
6669 (arg1)->Show(arg2);
6670
6671 wxPyEndAllowThreads(__tstate);
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 Py_INCREF(Py_None); resultobj = Py_None;
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6682 PyObject *resultobj;
6683 wxCaret *arg1 = (wxCaret *) 0 ;
6684 PyObject * obj0 = 0 ;
6685 char *kwnames[] = {
6686 (char *) "self", NULL
6687 };
6688
6689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6691 if (SWIG_arg_fail(1)) SWIG_fail;
6692 {
6693 PyThreadState* __tstate = wxPyBeginAllowThreads();
6694 (arg1)->Hide();
6695
6696 wxPyEndAllowThreads(__tstate);
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 Py_INCREF(Py_None); resultobj = Py_None;
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj;
6708 int result;
6709 char *kwnames[] = {
6710 NULL
6711 };
6712
6713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = (int)wxCaret::GetBlinkTime();
6717
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 {
6722 resultobj = SWIG_From_int((int)(result));
6723 }
6724 return resultobj;
6725 fail:
6726 return NULL;
6727 }
6728
6729
6730 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6731 PyObject *resultobj;
6732 int arg1 ;
6733 PyObject * obj0 = 0 ;
6734 char *kwnames[] = {
6735 (char *) "milliseconds", NULL
6736 };
6737
6738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6739 {
6740 arg1 = (int)(SWIG_As_int(obj0));
6741 if (SWIG_arg_fail(1)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 wxCaret::SetBlinkTime(arg1);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 Py_INCREF(Py_None); resultobj = Py_None;
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6758 PyObject *obj;
6759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6760 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6761 Py_INCREF(obj);
6762 return Py_BuildValue((char *)"");
6763 }
6764 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj;
6766 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6767 wxBusyCursor *result;
6768 PyObject * obj0 = 0 ;
6769 char *kwnames[] = {
6770 (char *) "cursor", NULL
6771 };
6772
6773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6774 if (obj0) {
6775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6776 if (SWIG_arg_fail(1)) SWIG_fail;
6777 }
6778 {
6779 if (!wxPyCheckForApp()) SWIG_fail;
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6782
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6794 PyObject *resultobj;
6795 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6796 PyObject * obj0 = 0 ;
6797 char *kwnames[] = {
6798 (char *) "self", NULL
6799 };
6800
6801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6803 if (SWIG_arg_fail(1)) SWIG_fail;
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 delete arg1;
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 Py_INCREF(Py_None); resultobj = Py_None;
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6819 PyObject *obj;
6820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6821 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6822 Py_INCREF(obj);
6823 return Py_BuildValue((char *)"");
6824 }
6825 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6826 PyObject *resultobj;
6827 wxWindow *arg1 = (wxWindow *) NULL ;
6828 wxWindowDisabler *result;
6829 PyObject * obj0 = 0 ;
6830 char *kwnames[] = {
6831 (char *) "winToSkip", NULL
6832 };
6833
6834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6835 if (obj0) {
6836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6837 if (SWIG_arg_fail(1)) SWIG_fail;
6838 }
6839 {
6840 if (!wxPyCheckForApp()) SWIG_fail;
6841 PyThreadState* __tstate = wxPyBeginAllowThreads();
6842 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6843
6844 wxPyEndAllowThreads(__tstate);
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj;
6856 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "self", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6864 if (SWIG_arg_fail(1)) SWIG_fail;
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 delete arg1;
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 Py_INCREF(Py_None); resultobj = Py_None;
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6880 PyObject *obj;
6881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6882 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6883 Py_INCREF(obj);
6884 return Py_BuildValue((char *)"");
6885 }
6886 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6887 PyObject *resultobj;
6888 wxString *arg1 = 0 ;
6889 wxBusyInfo *result;
6890 bool temp1 = false ;
6891 PyObject * obj0 = 0 ;
6892 char *kwnames[] = {
6893 (char *) "message", NULL
6894 };
6895
6896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6897 {
6898 arg1 = wxString_in_helper(obj0);
6899 if (arg1 == NULL) SWIG_fail;
6900 temp1 = true;
6901 }
6902 {
6903 if (!wxPyCheckForApp()) SWIG_fail;
6904 PyThreadState* __tstate = wxPyBeginAllowThreads();
6905 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6911 {
6912 if (temp1)
6913 delete arg1;
6914 }
6915 return resultobj;
6916 fail:
6917 {
6918 if (temp1)
6919 delete arg1;
6920 }
6921 return NULL;
6922 }
6923
6924
6925 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj;
6927 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6928 PyObject * obj0 = 0 ;
6929 char *kwnames[] = {
6930 (char *) "self", NULL
6931 };
6932
6933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6935 if (SWIG_arg_fail(1)) SWIG_fail;
6936 {
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 delete arg1;
6939
6940 wxPyEndAllowThreads(__tstate);
6941 if (PyErr_Occurred()) SWIG_fail;
6942 }
6943 Py_INCREF(Py_None); resultobj = Py_None;
6944 return resultobj;
6945 fail:
6946 return NULL;
6947 }
6948
6949
6950 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6951 PyObject *obj;
6952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6953 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6954 Py_INCREF(obj);
6955 return Py_BuildValue((char *)"");
6956 }
6957 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj;
6959 wxStopWatch *result;
6960 char *kwnames[] = {
6961 NULL
6962 };
6963
6964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 result = (wxStopWatch *)new wxStopWatch();
6968
6969 wxPyEndAllowThreads(__tstate);
6970 if (PyErr_Occurred()) SWIG_fail;
6971 }
6972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6973 return resultobj;
6974 fail:
6975 return NULL;
6976 }
6977
6978
6979 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6980 PyObject *resultobj;
6981 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6982 long arg2 = (long) 0 ;
6983 PyObject * obj0 = 0 ;
6984 PyObject * obj1 = 0 ;
6985 char *kwnames[] = {
6986 (char *) "self",(char *) "t0", NULL
6987 };
6988
6989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6991 if (SWIG_arg_fail(1)) SWIG_fail;
6992 if (obj1) {
6993 {
6994 arg2 = (long)(SWIG_As_long(obj1));
6995 if (SWIG_arg_fail(2)) SWIG_fail;
6996 }
6997 }
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 (arg1)->Start(arg2);
7001
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 Py_INCREF(Py_None); resultobj = Py_None;
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7013 PyObject *resultobj;
7014 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7015 PyObject * obj0 = 0 ;
7016 char *kwnames[] = {
7017 (char *) "self", NULL
7018 };
7019
7020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7022 if (SWIG_arg_fail(1)) SWIG_fail;
7023 {
7024 PyThreadState* __tstate = wxPyBeginAllowThreads();
7025 (arg1)->Pause();
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 Py_INCREF(Py_None); resultobj = Py_None;
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7040 PyObject * obj0 = 0 ;
7041 char *kwnames[] = {
7042 (char *) "self", NULL
7043 };
7044
7045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7047 if (SWIG_arg_fail(1)) SWIG_fail;
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 (arg1)->Resume();
7051
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 Py_INCREF(Py_None); resultobj = Py_None;
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7063 PyObject *resultobj;
7064 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7065 long result;
7066 PyObject * obj0 = 0 ;
7067 char *kwnames[] = {
7068 (char *) "self", NULL
7069 };
7070
7071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7073 if (SWIG_arg_fail(1)) SWIG_fail;
7074 {
7075 PyThreadState* __tstate = wxPyBeginAllowThreads();
7076 result = (long)((wxStopWatch const *)arg1)->Time();
7077
7078 wxPyEndAllowThreads(__tstate);
7079 if (PyErr_Occurred()) SWIG_fail;
7080 }
7081 {
7082 resultobj = SWIG_From_long((long)(result));
7083 }
7084 return resultobj;
7085 fail:
7086 return NULL;
7087 }
7088
7089
7090 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7091 PyObject *obj;
7092 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7093 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7094 Py_INCREF(obj);
7095 return Py_BuildValue((char *)"");
7096 }
7097 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7098 PyObject *resultobj;
7099 int arg1 = (int) 9 ;
7100 int arg2 = (int) wxID_FILE1 ;
7101 wxFileHistory *result;
7102 PyObject * obj0 = 0 ;
7103 PyObject * obj1 = 0 ;
7104 char *kwnames[] = {
7105 (char *) "maxFiles",(char *) "idBase", NULL
7106 };
7107
7108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7109 if (obj0) {
7110 {
7111 arg1 = (int)(SWIG_As_int(obj0));
7112 if (SWIG_arg_fail(1)) SWIG_fail;
7113 }
7114 }
7115 if (obj1) {
7116 {
7117 arg2 = (int)(SWIG_As_int(obj1));
7118 if (SWIG_arg_fail(2)) SWIG_fail;
7119 }
7120 }
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7124
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7136 PyObject *resultobj;
7137 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7138 PyObject * obj0 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "self", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(1)) SWIG_fail;
7146 {
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 delete arg1;
7149
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 Py_INCREF(Py_None); resultobj = Py_None;
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7161 PyObject *resultobj;
7162 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7163 wxString *arg2 = 0 ;
7164 bool temp2 = false ;
7165 PyObject * obj0 = 0 ;
7166 PyObject * obj1 = 0 ;
7167 char *kwnames[] = {
7168 (char *) "self",(char *) "file", NULL
7169 };
7170
7171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7173 if (SWIG_arg_fail(1)) SWIG_fail;
7174 {
7175 arg2 = wxString_in_helper(obj1);
7176 if (arg2 == NULL) SWIG_fail;
7177 temp2 = true;
7178 }
7179 {
7180 PyThreadState* __tstate = wxPyBeginAllowThreads();
7181 (arg1)->AddFileToHistory((wxString const &)*arg2);
7182
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 Py_INCREF(Py_None); resultobj = Py_None;
7187 {
7188 if (temp2)
7189 delete arg2;
7190 }
7191 return resultobj;
7192 fail:
7193 {
7194 if (temp2)
7195 delete arg2;
7196 }
7197 return NULL;
7198 }
7199
7200
7201 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj;
7203 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7204 int arg2 ;
7205 PyObject * obj0 = 0 ;
7206 PyObject * obj1 = 0 ;
7207 char *kwnames[] = {
7208 (char *) "self",(char *) "i", NULL
7209 };
7210
7211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7213 if (SWIG_arg_fail(1)) SWIG_fail;
7214 {
7215 arg2 = (int)(SWIG_As_int(obj1));
7216 if (SWIG_arg_fail(2)) SWIG_fail;
7217 }
7218 {
7219 PyThreadState* __tstate = wxPyBeginAllowThreads();
7220 (arg1)->RemoveFileFromHistory(arg2);
7221
7222 wxPyEndAllowThreads(__tstate);
7223 if (PyErr_Occurred()) SWIG_fail;
7224 }
7225 Py_INCREF(Py_None); resultobj = Py_None;
7226 return resultobj;
7227 fail:
7228 return NULL;
7229 }
7230
7231
7232 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7233 PyObject *resultobj;
7234 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7235 int result;
7236 PyObject * obj0 = 0 ;
7237 char *kwnames[] = {
7238 (char *) "self", NULL
7239 };
7240
7241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7243 if (SWIG_arg_fail(1)) SWIG_fail;
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7247
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 {
7252 resultobj = SWIG_From_int((int)(result));
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj;
7262 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7263 wxMenu *arg2 = (wxMenu *) 0 ;
7264 PyObject * obj0 = 0 ;
7265 PyObject * obj1 = 0 ;
7266 char *kwnames[] = {
7267 (char *) "self",(char *) "menu", NULL
7268 };
7269
7270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7272 if (SWIG_arg_fail(1)) SWIG_fail;
7273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7274 if (SWIG_arg_fail(2)) SWIG_fail;
7275 {
7276 PyThreadState* __tstate = wxPyBeginAllowThreads();
7277 (arg1)->UseMenu(arg2);
7278
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 Py_INCREF(Py_None); resultobj = Py_None;
7283 return resultobj;
7284 fail:
7285 return NULL;
7286 }
7287
7288
7289 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7290 PyObject *resultobj;
7291 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7292 wxMenu *arg2 = (wxMenu *) 0 ;
7293 PyObject * obj0 = 0 ;
7294 PyObject * obj1 = 0 ;
7295 char *kwnames[] = {
7296 (char *) "self",(char *) "menu", NULL
7297 };
7298
7299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7301 if (SWIG_arg_fail(1)) SWIG_fail;
7302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(2)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 (arg1)->RemoveMenu(arg2);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 Py_INCREF(Py_None); resultobj = Py_None;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj;
7320 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7321 wxConfigBase *arg2 = 0 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 char *kwnames[] = {
7325 (char *) "self",(char *) "config", NULL
7326 };
7327
7328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7330 if (SWIG_arg_fail(1)) SWIG_fail;
7331 {
7332 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7333 if (SWIG_arg_fail(2)) SWIG_fail;
7334 if (arg2 == NULL) {
7335 SWIG_null_ref("wxConfigBase");
7336 }
7337 if (SWIG_arg_fail(2)) SWIG_fail;
7338 }
7339 {
7340 PyThreadState* __tstate = wxPyBeginAllowThreads();
7341 (arg1)->Load(*arg2);
7342
7343 wxPyEndAllowThreads(__tstate);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 Py_INCREF(Py_None); resultobj = Py_None;
7347 return resultobj;
7348 fail:
7349 return NULL;
7350 }
7351
7352
7353 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj;
7355 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7356 wxConfigBase *arg2 = 0 ;
7357 PyObject * obj0 = 0 ;
7358 PyObject * obj1 = 0 ;
7359 char *kwnames[] = {
7360 (char *) "self",(char *) "config", NULL
7361 };
7362
7363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7365 if (SWIG_arg_fail(1)) SWIG_fail;
7366 {
7367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7368 if (SWIG_arg_fail(2)) SWIG_fail;
7369 if (arg2 == NULL) {
7370 SWIG_null_ref("wxConfigBase");
7371 }
7372 if (SWIG_arg_fail(2)) SWIG_fail;
7373 }
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 (arg1)->Save(*arg2);
7377
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 Py_INCREF(Py_None); resultobj = Py_None;
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj;
7390 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7391 PyObject * obj0 = 0 ;
7392 char *kwnames[] = {
7393 (char *) "self", NULL
7394 };
7395
7396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(1)) SWIG_fail;
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 (arg1)->AddFilesToMenu();
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 Py_INCREF(Py_None); resultobj = Py_None;
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj;
7415 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7416 wxMenu *arg2 = (wxMenu *) 0 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char *kwnames[] = {
7420 (char *) "self",(char *) "menu", NULL
7421 };
7422
7423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7425 if (SWIG_arg_fail(1)) SWIG_fail;
7426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7427 if (SWIG_arg_fail(2)) SWIG_fail;
7428 {
7429 PyThreadState* __tstate = wxPyBeginAllowThreads();
7430 (arg1)->AddFilesToMenu(arg2);
7431
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 Py_INCREF(Py_None); resultobj = Py_None;
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj;
7444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7445 int arg2 ;
7446 wxString result;
7447 PyObject * obj0 = 0 ;
7448 PyObject * obj1 = 0 ;
7449 char *kwnames[] = {
7450 (char *) "self",(char *) "i", NULL
7451 };
7452
7453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7455 if (SWIG_arg_fail(1)) SWIG_fail;
7456 {
7457 arg2 = (int)(SWIG_As_int(obj1));
7458 if (SWIG_arg_fail(2)) SWIG_fail;
7459 }
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7463
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 {
7468 #if wxUSE_UNICODE
7469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7470 #else
7471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7472 #endif
7473 }
7474 return resultobj;
7475 fail:
7476 return NULL;
7477 }
7478
7479
7480 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7481 PyObject *resultobj;
7482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7483 int result;
7484 PyObject * obj0 = 0 ;
7485 char *kwnames[] = {
7486 (char *) "self", NULL
7487 };
7488
7489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7491 if (SWIG_arg_fail(1)) SWIG_fail;
7492 {
7493 PyThreadState* __tstate = wxPyBeginAllowThreads();
7494 result = (int)((wxFileHistory const *)arg1)->GetCount();
7495
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 {
7500 resultobj = SWIG_From_int((int)(result));
7501 }
7502 return resultobj;
7503 fail:
7504 return NULL;
7505 }
7506
7507
7508 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7509 PyObject *obj;
7510 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7511 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7512 Py_INCREF(obj);
7513 return Py_BuildValue((char *)"");
7514 }
7515 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj;
7517 wxString *arg1 = 0 ;
7518 wxString const &arg2_defvalue = wxPyEmptyString ;
7519 wxString *arg2 = (wxString *) &arg2_defvalue ;
7520 wxSingleInstanceChecker *result;
7521 bool temp1 = false ;
7522 bool temp2 = false ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char *kwnames[] = {
7526 (char *) "name",(char *) "path", NULL
7527 };
7528
7529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7530 {
7531 arg1 = wxString_in_helper(obj0);
7532 if (arg1 == NULL) SWIG_fail;
7533 temp1 = true;
7534 }
7535 if (obj1) {
7536 {
7537 arg2 = wxString_in_helper(obj1);
7538 if (arg2 == NULL) SWIG_fail;
7539 temp2 = true;
7540 }
7541 }
7542 {
7543 PyThreadState* __tstate = wxPyBeginAllowThreads();
7544 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7545
7546 wxPyEndAllowThreads(__tstate);
7547 if (PyErr_Occurred()) SWIG_fail;
7548 }
7549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7550 {
7551 if (temp1)
7552 delete arg1;
7553 }
7554 {
7555 if (temp2)
7556 delete arg2;
7557 }
7558 return resultobj;
7559 fail:
7560 {
7561 if (temp1)
7562 delete arg1;
7563 }
7564 {
7565 if (temp2)
7566 delete arg2;
7567 }
7568 return NULL;
7569 }
7570
7571
7572 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7573 PyObject *resultobj;
7574 wxSingleInstanceChecker *result;
7575 char *kwnames[] = {
7576 NULL
7577 };
7578
7579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7583
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj;
7596 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7597 PyObject * obj0 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 delete arg1;
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 Py_INCREF(Py_None); resultobj = Py_None;
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7620 PyObject *resultobj;
7621 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7622 wxString *arg2 = 0 ;
7623 wxString const &arg3_defvalue = wxPyEmptyString ;
7624 wxString *arg3 = (wxString *) &arg3_defvalue ;
7625 bool result;
7626 bool temp2 = false ;
7627 bool temp3 = false ;
7628 PyObject * obj0 = 0 ;
7629 PyObject * obj1 = 0 ;
7630 PyObject * obj2 = 0 ;
7631 char *kwnames[] = {
7632 (char *) "self",(char *) "name",(char *) "path", NULL
7633 };
7634
7635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7637 if (SWIG_arg_fail(1)) SWIG_fail;
7638 {
7639 arg2 = wxString_in_helper(obj1);
7640 if (arg2 == NULL) SWIG_fail;
7641 temp2 = true;
7642 }
7643 if (obj2) {
7644 {
7645 arg3 = wxString_in_helper(obj2);
7646 if (arg3 == NULL) SWIG_fail;
7647 temp3 = true;
7648 }
7649 }
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7659 }
7660 {
7661 if (temp2)
7662 delete arg2;
7663 }
7664 {
7665 if (temp3)
7666 delete arg3;
7667 }
7668 return resultobj;
7669 fail:
7670 {
7671 if (temp2)
7672 delete arg2;
7673 }
7674 {
7675 if (temp3)
7676 delete arg3;
7677 }
7678 return NULL;
7679 }
7680
7681
7682 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj;
7684 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7685 bool result;
7686 PyObject * obj0 = 0 ;
7687 char *kwnames[] = {
7688 (char *) "self", NULL
7689 };
7690
7691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7693 if (SWIG_arg_fail(1)) SWIG_fail;
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7697
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 {
7702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7703 }
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7711 PyObject *obj;
7712 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7713 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7714 Py_INCREF(obj);
7715 return Py_BuildValue((char *)"");
7716 }
7717 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj;
7719 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7720 PyObject * obj0 = 0 ;
7721 char *kwnames[] = {
7722 (char *) "self", NULL
7723 };
7724
7725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7727 if (SWIG_arg_fail(1)) SWIG_fail;
7728 {
7729 PyThreadState* __tstate = wxPyBeginAllowThreads();
7730 delete arg1;
7731
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 Py_INCREF(Py_None); resultobj = Py_None;
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj;
7744 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7745 wxString result;
7746 PyObject * obj0 = 0 ;
7747 char *kwnames[] = {
7748 (char *) "self", NULL
7749 };
7750
7751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7753 if (SWIG_arg_fail(1)) SWIG_fail;
7754 {
7755 PyThreadState* __tstate = wxPyBeginAllowThreads();
7756 result = (arg1)->GetTip();
7757
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 {
7762 #if wxUSE_UNICODE
7763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7764 #else
7765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7766 #endif
7767 }
7768 return resultobj;
7769 fail:
7770 return NULL;
7771 }
7772
7773
7774 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7775 PyObject *resultobj;
7776 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7777 size_t result;
7778 PyObject * obj0 = 0 ;
7779 char *kwnames[] = {
7780 (char *) "self", NULL
7781 };
7782
7783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7785 if (SWIG_arg_fail(1)) SWIG_fail;
7786 {
7787 PyThreadState* __tstate = wxPyBeginAllowThreads();
7788 result = (size_t)(arg1)->GetCurrentTip();
7789
7790 wxPyEndAllowThreads(__tstate);
7791 if (PyErr_Occurred()) SWIG_fail;
7792 }
7793 {
7794 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7795 }
7796 return resultobj;
7797 fail:
7798 return NULL;
7799 }
7800
7801
7802 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7803 PyObject *resultobj;
7804 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7805 wxString *arg2 = 0 ;
7806 wxString result;
7807 bool temp2 = false ;
7808 PyObject * obj0 = 0 ;
7809 PyObject * obj1 = 0 ;
7810 char *kwnames[] = {
7811 (char *) "self",(char *) "tip", NULL
7812 };
7813
7814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7816 if (SWIG_arg_fail(1)) SWIG_fail;
7817 {
7818 arg2 = wxString_in_helper(obj1);
7819 if (arg2 == NULL) SWIG_fail;
7820 temp2 = true;
7821 }
7822 {
7823 PyThreadState* __tstate = wxPyBeginAllowThreads();
7824 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7825
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 {
7830 #if wxUSE_UNICODE
7831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7832 #else
7833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7834 #endif
7835 }
7836 {
7837 if (temp2)
7838 delete arg2;
7839 }
7840 return resultobj;
7841 fail:
7842 {
7843 if (temp2)
7844 delete arg2;
7845 }
7846 return NULL;
7847 }
7848
7849
7850 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7851 PyObject *obj;
7852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7853 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7854 Py_INCREF(obj);
7855 return Py_BuildValue((char *)"");
7856 }
7857 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7858 PyObject *resultobj;
7859 size_t arg1 ;
7860 wxPyTipProvider *result;
7861 PyObject * obj0 = 0 ;
7862 char *kwnames[] = {
7863 (char *) "currentTip", NULL
7864 };
7865
7866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7867 {
7868 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7869 if (SWIG_arg_fail(1)) SWIG_fail;
7870 }
7871 {
7872 PyThreadState* __tstate = wxPyBeginAllowThreads();
7873 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7874
7875 wxPyEndAllowThreads(__tstate);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7886 PyObject *resultobj;
7887 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7888 PyObject *arg2 = (PyObject *) 0 ;
7889 PyObject *arg3 = (PyObject *) 0 ;
7890 PyObject * obj0 = 0 ;
7891 PyObject * obj1 = 0 ;
7892 PyObject * obj2 = 0 ;
7893 char *kwnames[] = {
7894 (char *) "self",(char *) "self",(char *) "_class", NULL
7895 };
7896
7897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7899 if (SWIG_arg_fail(1)) SWIG_fail;
7900 arg2 = obj1;
7901 arg3 = obj2;
7902 {
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 (arg1)->_setCallbackInfo(arg2,arg3);
7905
7906 wxPyEndAllowThreads(__tstate);
7907 if (PyErr_Occurred()) SWIG_fail;
7908 }
7909 Py_INCREF(Py_None); resultobj = Py_None;
7910 return resultobj;
7911 fail:
7912 return NULL;
7913 }
7914
7915
7916 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7917 PyObject *obj;
7918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7919 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7920 Py_INCREF(obj);
7921 return Py_BuildValue((char *)"");
7922 }
7923 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7924 PyObject *resultobj;
7925 wxWindow *arg1 = (wxWindow *) 0 ;
7926 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7927 bool arg3 = (bool) true ;
7928 bool result;
7929 PyObject * obj0 = 0 ;
7930 PyObject * obj1 = 0 ;
7931 PyObject * obj2 = 0 ;
7932 char *kwnames[] = {
7933 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7934 };
7935
7936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7938 if (SWIG_arg_fail(1)) SWIG_fail;
7939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7940 if (SWIG_arg_fail(2)) SWIG_fail;
7941 if (obj2) {
7942 {
7943 arg3 = (bool)(SWIG_As_bool(obj2));
7944 if (SWIG_arg_fail(3)) SWIG_fail;
7945 }
7946 }
7947 {
7948 if (!wxPyCheckForApp()) SWIG_fail;
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 result = (bool)wxShowTip(arg1,arg2,arg3);
7951
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 {
7956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7957 }
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7965 PyObject *resultobj;
7966 wxString *arg1 = 0 ;
7967 size_t arg2 ;
7968 wxTipProvider *result;
7969 bool temp1 = false ;
7970 PyObject * obj0 = 0 ;
7971 PyObject * obj1 = 0 ;
7972 char *kwnames[] = {
7973 (char *) "filename",(char *) "currentTip", NULL
7974 };
7975
7976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7977 {
7978 arg1 = wxString_in_helper(obj0);
7979 if (arg1 == NULL) SWIG_fail;
7980 temp1 = true;
7981 }
7982 {
7983 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7984 if (SWIG_arg_fail(2)) SWIG_fail;
7985 }
7986 {
7987 if (!wxPyCheckForApp()) SWIG_fail;
7988 PyThreadState* __tstate = wxPyBeginAllowThreads();
7989 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7990
7991 wxPyEndAllowThreads(__tstate);
7992 if (PyErr_Occurred()) SWIG_fail;
7993 }
7994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
7995 {
7996 if (temp1)
7997 delete arg1;
7998 }
7999 return resultobj;
8000 fail:
8001 {
8002 if (temp1)
8003 delete arg1;
8004 }
8005 return NULL;
8006 }
8007
8008
8009 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj;
8011 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8012 int arg2 = (int) -1 ;
8013 wxPyTimer *result;
8014 PyObject * obj0 = 0 ;
8015 PyObject * obj1 = 0 ;
8016 char *kwnames[] = {
8017 (char *) "owner",(char *) "id", NULL
8018 };
8019
8020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8021 if (obj0) {
8022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8023 if (SWIG_arg_fail(1)) SWIG_fail;
8024 }
8025 if (obj1) {
8026 {
8027 arg2 = (int)(SWIG_As_int(obj1));
8028 if (SWIG_arg_fail(2)) SWIG_fail;
8029 }
8030 }
8031 {
8032 if (!wxPyCheckForApp()) SWIG_fail;
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8035
8036 wxPyEndAllowThreads(__tstate);
8037 if (PyErr_Occurred()) SWIG_fail;
8038 }
8039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8040 return resultobj;
8041 fail:
8042 return NULL;
8043 }
8044
8045
8046 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8047 PyObject *resultobj;
8048 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8049 PyObject * obj0 = 0 ;
8050 char *kwnames[] = {
8051 (char *) "self", NULL
8052 };
8053
8054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8056 if (SWIG_arg_fail(1)) SWIG_fail;
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 delete arg1;
8060
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 Py_INCREF(Py_None); resultobj = Py_None;
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj;
8073 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8074 PyObject *arg2 = (PyObject *) 0 ;
8075 PyObject *arg3 = (PyObject *) 0 ;
8076 int arg4 = (int) 1 ;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 PyObject * obj2 = 0 ;
8080 PyObject * obj3 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 arg2 = obj1;
8089 arg3 = obj2;
8090 if (obj3) {
8091 {
8092 arg4 = (int)(SWIG_As_int(obj3));
8093 if (SWIG_arg_fail(4)) SWIG_fail;
8094 }
8095 }
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 Py_INCREF(Py_None); resultobj = Py_None;
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj;
8112 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8113 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8114 int arg3 = (int) -1 ;
8115 PyObject * obj0 = 0 ;
8116 PyObject * obj1 = 0 ;
8117 PyObject * obj2 = 0 ;
8118 char *kwnames[] = {
8119 (char *) "self",(char *) "owner",(char *) "id", NULL
8120 };
8121
8122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8124 if (SWIG_arg_fail(1)) SWIG_fail;
8125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8126 if (SWIG_arg_fail(2)) SWIG_fail;
8127 if (obj2) {
8128 {
8129 arg3 = (int)(SWIG_As_int(obj2));
8130 if (SWIG_arg_fail(3)) SWIG_fail;
8131 }
8132 }
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 (arg1)->SetOwner(arg2,arg3);
8136
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 Py_INCREF(Py_None); resultobj = Py_None;
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj;
8149 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8150 wxEvtHandler *result;
8151 PyObject * obj0 = 0 ;
8152 char *kwnames[] = {
8153 (char *) "self", NULL
8154 };
8155
8156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8158 if (SWIG_arg_fail(1)) SWIG_fail;
8159 {
8160 PyThreadState* __tstate = wxPyBeginAllowThreads();
8161 result = (wxEvtHandler *)(arg1)->GetOwner();
8162
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 {
8167 resultobj = wxPyMake_wxObject(result, 0);
8168 }
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8176 PyObject *resultobj;
8177 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8178 int arg2 = (int) -1 ;
8179 bool arg3 = (bool) false ;
8180 bool result;
8181 PyObject * obj0 = 0 ;
8182 PyObject * obj1 = 0 ;
8183 PyObject * obj2 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 if (obj1) {
8192 {
8193 arg2 = (int)(SWIG_As_int(obj1));
8194 if (SWIG_arg_fail(2)) SWIG_fail;
8195 }
8196 }
8197 if (obj2) {
8198 {
8199 arg3 = (bool)(SWIG_As_bool(obj2));
8200 if (SWIG_arg_fail(3)) SWIG_fail;
8201 }
8202 }
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 result = (bool)(arg1)->Start(arg2,arg3);
8206
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 {
8211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8212 }
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8222 PyObject * obj0 = 0 ;
8223 char *kwnames[] = {
8224 (char *) "self", NULL
8225 };
8226
8227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8229 if (SWIG_arg_fail(1)) SWIG_fail;
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 (arg1)->Stop();
8233
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 Py_INCREF(Py_None); resultobj = Py_None;
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj;
8246 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8247 bool result;
8248 PyObject * obj0 = 0 ;
8249 char *kwnames[] = {
8250 (char *) "self", NULL
8251 };
8252
8253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8255 if (SWIG_arg_fail(1)) SWIG_fail;
8256 {
8257 PyThreadState* __tstate = wxPyBeginAllowThreads();
8258 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8259
8260 wxPyEndAllowThreads(__tstate);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 {
8264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8265 }
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj;
8274 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8275 int result;
8276 PyObject * obj0 = 0 ;
8277 char *kwnames[] = {
8278 (char *) "self", NULL
8279 };
8280
8281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8283 if (SWIG_arg_fail(1)) SWIG_fail;
8284 {
8285 PyThreadState* __tstate = wxPyBeginAllowThreads();
8286 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8287
8288 wxPyEndAllowThreads(__tstate);
8289 if (PyErr_Occurred()) SWIG_fail;
8290 }
8291 {
8292 resultobj = SWIG_From_int((int)(result));
8293 }
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj;
8302 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8303 bool result;
8304 PyObject * obj0 = 0 ;
8305 char *kwnames[] = {
8306 (char *) "self", NULL
8307 };
8308
8309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(1)) SWIG_fail;
8312 {
8313 PyThreadState* __tstate = wxPyBeginAllowThreads();
8314 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8315
8316 wxPyEndAllowThreads(__tstate);
8317 if (PyErr_Occurred()) SWIG_fail;
8318 }
8319 {
8320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8321 }
8322 return resultobj;
8323 fail:
8324 return NULL;
8325 }
8326
8327
8328 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8329 PyObject *resultobj;
8330 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8331 int result;
8332 PyObject * obj0 = 0 ;
8333 char *kwnames[] = {
8334 (char *) "self", NULL
8335 };
8336
8337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8339 if (SWIG_arg_fail(1)) SWIG_fail;
8340 {
8341 PyThreadState* __tstate = wxPyBeginAllowThreads();
8342 result = (int)((wxPyTimer const *)arg1)->GetId();
8343
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 {
8348 resultobj = SWIG_From_int((int)(result));
8349 }
8350 return resultobj;
8351 fail:
8352 return NULL;
8353 }
8354
8355
8356 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8357 PyObject *obj;
8358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8359 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8360 Py_INCREF(obj);
8361 return Py_BuildValue((char *)"");
8362 }
8363 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8364 PyObject *resultobj;
8365 int arg1 = (int) 0 ;
8366 int arg2 = (int) 0 ;
8367 wxTimerEvent *result;
8368 PyObject * obj0 = 0 ;
8369 PyObject * obj1 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "timerid",(char *) "interval", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8375 if (obj0) {
8376 {
8377 arg1 = (int)(SWIG_As_int(obj0));
8378 if (SWIG_arg_fail(1)) SWIG_fail;
8379 }
8380 }
8381 if (obj1) {
8382 {
8383 arg2 = (int)(SWIG_As_int(obj1));
8384 if (SWIG_arg_fail(2)) SWIG_fail;
8385 }
8386 }
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj;
8403 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8404 int result;
8405 PyObject * obj0 = 0 ;
8406 char *kwnames[] = {
8407 (char *) "self", NULL
8408 };
8409
8410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8412 if (SWIG_arg_fail(1)) SWIG_fail;
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8416
8417 wxPyEndAllowThreads(__tstate);
8418 if (PyErr_Occurred()) SWIG_fail;
8419 }
8420 {
8421 resultobj = SWIG_From_int((int)(result));
8422 }
8423 return resultobj;
8424 fail:
8425 return NULL;
8426 }
8427
8428
8429 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8430 PyObject *obj;
8431 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8432 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8433 Py_INCREF(obj);
8434 return Py_BuildValue((char *)"");
8435 }
8436 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8437 PyObject *resultobj;
8438 wxTimer *arg1 = 0 ;
8439 wxTimerRunner *result;
8440 PyObject * obj0 = 0 ;
8441
8442 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8443 {
8444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8445 if (SWIG_arg_fail(1)) SWIG_fail;
8446 if (arg1 == NULL) {
8447 SWIG_null_ref("wxTimer");
8448 }
8449 if (SWIG_arg_fail(1)) SWIG_fail;
8450 }
8451 {
8452 if (!wxPyCheckForApp()) SWIG_fail;
8453 PyThreadState* __tstate = wxPyBeginAllowThreads();
8454 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8455
8456 wxPyEndAllowThreads(__tstate);
8457 if (PyErr_Occurred()) SWIG_fail;
8458 }
8459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8467 PyObject *resultobj;
8468 wxTimer *arg1 = 0 ;
8469 int arg2 ;
8470 bool arg3 = (bool) false ;
8471 wxTimerRunner *result;
8472 PyObject * obj0 = 0 ;
8473 PyObject * obj1 = 0 ;
8474 PyObject * obj2 = 0 ;
8475
8476 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8477 {
8478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8479 if (SWIG_arg_fail(1)) SWIG_fail;
8480 if (arg1 == NULL) {
8481 SWIG_null_ref("wxTimer");
8482 }
8483 if (SWIG_arg_fail(1)) SWIG_fail;
8484 }
8485 {
8486 arg2 = (int)(SWIG_As_int(obj1));
8487 if (SWIG_arg_fail(2)) SWIG_fail;
8488 }
8489 if (obj2) {
8490 {
8491 arg3 = (bool)(SWIG_As_bool(obj2));
8492 if (SWIG_arg_fail(3)) SWIG_fail;
8493 }
8494 }
8495 {
8496 if (!wxPyCheckForApp()) SWIG_fail;
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8499
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8511 int argc;
8512 PyObject *argv[4];
8513 int ii;
8514
8515 argc = PyObject_Length(args);
8516 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8517 argv[ii] = PyTuple_GetItem(args,ii);
8518 }
8519 if (argc == 1) {
8520 int _v;
8521 {
8522 void *ptr = 0;
8523 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8524 _v = 0;
8525 PyErr_Clear();
8526 } else {
8527 _v = (ptr != 0);
8528 }
8529 }
8530 if (_v) {
8531 return _wrap_new_TimerRunner__SWIG_0(self,args);
8532 }
8533 }
8534 if ((argc >= 2) && (argc <= 3)) {
8535 int _v;
8536 {
8537 void *ptr = 0;
8538 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8539 _v = 0;
8540 PyErr_Clear();
8541 } else {
8542 _v = (ptr != 0);
8543 }
8544 }
8545 if (_v) {
8546 _v = SWIG_Check_int(argv[1]);
8547 if (_v) {
8548 if (argc <= 2) {
8549 return _wrap_new_TimerRunner__SWIG_1(self,args);
8550 }
8551 _v = SWIG_Check_bool(argv[2]);
8552 if (_v) {
8553 return _wrap_new_TimerRunner__SWIG_1(self,args);
8554 }
8555 }
8556 }
8557 }
8558
8559 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8560 return NULL;
8561 }
8562
8563
8564 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8565 PyObject *resultobj;
8566 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8567 PyObject * obj0 = 0 ;
8568 char *kwnames[] = {
8569 (char *) "self", NULL
8570 };
8571
8572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8574 if (SWIG_arg_fail(1)) SWIG_fail;
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 delete arg1;
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 Py_INCREF(Py_None); resultobj = Py_None;
8583 return resultobj;
8584 fail:
8585 return NULL;
8586 }
8587
8588
8589 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8590 PyObject *resultobj;
8591 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8592 int arg2 ;
8593 bool arg3 = (bool) false ;
8594 PyObject * obj0 = 0 ;
8595 PyObject * obj1 = 0 ;
8596 PyObject * obj2 = 0 ;
8597 char *kwnames[] = {
8598 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8599 };
8600
8601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8603 if (SWIG_arg_fail(1)) SWIG_fail;
8604 {
8605 arg2 = (int)(SWIG_As_int(obj1));
8606 if (SWIG_arg_fail(2)) SWIG_fail;
8607 }
8608 if (obj2) {
8609 {
8610 arg3 = (bool)(SWIG_As_bool(obj2));
8611 if (SWIG_arg_fail(3)) SWIG_fail;
8612 }
8613 }
8614 {
8615 PyThreadState* __tstate = wxPyBeginAllowThreads();
8616 (arg1)->Start(arg2,arg3);
8617
8618 wxPyEndAllowThreads(__tstate);
8619 if (PyErr_Occurred()) SWIG_fail;
8620 }
8621 Py_INCREF(Py_None); resultobj = Py_None;
8622 return resultobj;
8623 fail:
8624 return NULL;
8625 }
8626
8627
8628 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8629 PyObject *obj;
8630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8631 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8632 Py_INCREF(obj);
8633 return Py_BuildValue((char *)"");
8634 }
8635 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj;
8637 wxLog *result;
8638 char *kwnames[] = {
8639 NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8643 {
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 result = (wxLog *)new wxLog();
8646
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj;
8659 bool result;
8660 char *kwnames[] = {
8661 NULL
8662 };
8663
8664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8665 {
8666 PyThreadState* __tstate = wxPyBeginAllowThreads();
8667 result = (bool)wxLog::IsEnabled();
8668
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 {
8673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8674 }
8675 return resultobj;
8676 fail:
8677 return NULL;
8678 }
8679
8680
8681 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj;
8683 bool arg1 = (bool) true ;
8684 bool result;
8685 PyObject * obj0 = 0 ;
8686 char *kwnames[] = {
8687 (char *) "doIt", NULL
8688 };
8689
8690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8691 if (obj0) {
8692 {
8693 arg1 = (bool)(SWIG_As_bool(obj0));
8694 if (SWIG_arg_fail(1)) SWIG_fail;
8695 }
8696 }
8697 {
8698 PyThreadState* __tstate = wxPyBeginAllowThreads();
8699 result = (bool)wxLog::EnableLogging(arg1);
8700
8701 wxPyEndAllowThreads(__tstate);
8702 if (PyErr_Occurred()) SWIG_fail;
8703 }
8704 {
8705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8706 }
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8714 PyObject *resultobj;
8715 wxLogLevel arg1 ;
8716 wxChar *arg2 = (wxChar *) 0 ;
8717 time_t arg3 ;
8718 PyObject * obj0 = 0 ;
8719 PyObject * obj1 = 0 ;
8720 PyObject * obj2 = 0 ;
8721 char *kwnames[] = {
8722 (char *) "level",(char *) "szString",(char *) "t", NULL
8723 };
8724
8725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8726 {
8727 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 }
8730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8731 if (SWIG_arg_fail(2)) SWIG_fail;
8732 {
8733 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8734 if (SWIG_arg_fail(3)) SWIG_fail;
8735 }
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8739
8740 wxPyEndAllowThreads(__tstate);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 Py_INCREF(Py_None); resultobj = Py_None;
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj;
8752 wxLog *arg1 = (wxLog *) 0 ;
8753 PyObject * obj0 = 0 ;
8754 char *kwnames[] = {
8755 (char *) "self", NULL
8756 };
8757
8758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8760 if (SWIG_arg_fail(1)) SWIG_fail;
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 (arg1)->Flush();
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 return resultobj;
8770 fail:
8771 return NULL;
8772 }
8773
8774
8775 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8776 PyObject *resultobj;
8777 char *kwnames[] = {
8778 NULL
8779 };
8780
8781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 wxLog::FlushActive();
8785
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 Py_INCREF(Py_None); resultobj = Py_None;
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj;
8798 wxLog *result;
8799 char *kwnames[] = {
8800 NULL
8801 };
8802
8803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 result = (wxLog *)wxLog::GetActiveTarget();
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8812 return resultobj;
8813 fail:
8814 return NULL;
8815 }
8816
8817
8818 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8819 PyObject *resultobj;
8820 wxLog *arg1 = (wxLog *) 0 ;
8821 wxLog *result;
8822 PyObject * obj0 = 0 ;
8823 char *kwnames[] = {
8824 (char *) "pLogger", NULL
8825 };
8826
8827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8829 if (SWIG_arg_fail(1)) SWIG_fail;
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8833
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8838 return resultobj;
8839 fail:
8840 return NULL;
8841 }
8842
8843
8844 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8845 PyObject *resultobj;
8846 char *kwnames[] = {
8847 NULL
8848 };
8849
8850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 wxLog::Suspend();
8854
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 Py_INCREF(Py_None); resultobj = Py_None;
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj;
8867 char *kwnames[] = {
8868 NULL
8869 };
8870
8871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8872 {
8873 PyThreadState* __tstate = wxPyBeginAllowThreads();
8874 wxLog::Resume();
8875
8876 wxPyEndAllowThreads(__tstate);
8877 if (PyErr_Occurred()) SWIG_fail;
8878 }
8879 Py_INCREF(Py_None); resultobj = Py_None;
8880 return resultobj;
8881 fail:
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj;
8888 bool arg1 = (bool) true ;
8889 PyObject * obj0 = 0 ;
8890 char *kwnames[] = {
8891 (char *) "bVerbose", NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8895 if (obj0) {
8896 {
8897 arg1 = (bool)(SWIG_As_bool(obj0));
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 }
8900 }
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 wxLog::SetVerbose(arg1);
8904
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 Py_INCREF(Py_None); resultobj = Py_None;
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj;
8917 wxLogLevel arg1 ;
8918 PyObject * obj0 = 0 ;
8919 char *kwnames[] = {
8920 (char *) "logLevel", NULL
8921 };
8922
8923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8924 {
8925 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 }
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 wxLog::SetLogLevel(arg1);
8931
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 Py_INCREF(Py_None); resultobj = Py_None;
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8943 PyObject *resultobj;
8944 char *kwnames[] = {
8945 NULL
8946 };
8947
8948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8949 {
8950 PyThreadState* __tstate = wxPyBeginAllowThreads();
8951 wxLog::DontCreateOnDemand();
8952
8953 wxPyEndAllowThreads(__tstate);
8954 if (PyErr_Occurred()) SWIG_fail;
8955 }
8956 Py_INCREF(Py_None); resultobj = Py_None;
8957 return resultobj;
8958 fail:
8959 return NULL;
8960 }
8961
8962
8963 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj;
8965 wxTraceMask arg1 ;
8966 PyObject * obj0 = 0 ;
8967 char *kwnames[] = {
8968 (char *) "ulMask", NULL
8969 };
8970
8971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8972 {
8973 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8974 if (SWIG_arg_fail(1)) SWIG_fail;
8975 }
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 wxLog::SetTraceMask(arg1);
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 Py_INCREF(Py_None); resultobj = Py_None;
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxString *arg1 = 0 ;
8993 bool temp1 = false ;
8994 PyObject * obj0 = 0 ;
8995 char *kwnames[] = {
8996 (char *) "str", NULL
8997 };
8998
8999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9000 {
9001 arg1 = wxString_in_helper(obj0);
9002 if (arg1 == NULL) SWIG_fail;
9003 temp1 = true;
9004 }
9005 {
9006 PyThreadState* __tstate = wxPyBeginAllowThreads();
9007 wxLog::AddTraceMask((wxString const &)*arg1);
9008
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 Py_INCREF(Py_None); resultobj = Py_None;
9013 {
9014 if (temp1)
9015 delete arg1;
9016 }
9017 return resultobj;
9018 fail:
9019 {
9020 if (temp1)
9021 delete arg1;
9022 }
9023 return NULL;
9024 }
9025
9026
9027 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9028 PyObject *resultobj;
9029 wxString *arg1 = 0 ;
9030 bool temp1 = false ;
9031 PyObject * obj0 = 0 ;
9032 char *kwnames[] = {
9033 (char *) "str", NULL
9034 };
9035
9036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9037 {
9038 arg1 = wxString_in_helper(obj0);
9039 if (arg1 == NULL) SWIG_fail;
9040 temp1 = true;
9041 }
9042 {
9043 PyThreadState* __tstate = wxPyBeginAllowThreads();
9044 wxLog::RemoveTraceMask((wxString const &)*arg1);
9045
9046 wxPyEndAllowThreads(__tstate);
9047 if (PyErr_Occurred()) SWIG_fail;
9048 }
9049 Py_INCREF(Py_None); resultobj = Py_None;
9050 {
9051 if (temp1)
9052 delete arg1;
9053 }
9054 return resultobj;
9055 fail:
9056 {
9057 if (temp1)
9058 delete arg1;
9059 }
9060 return NULL;
9061 }
9062
9063
9064 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9065 PyObject *resultobj;
9066 char *kwnames[] = {
9067 NULL
9068 };
9069
9070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 wxLog::ClearTraceMasks();
9074
9075 wxPyEndAllowThreads(__tstate);
9076 if (PyErr_Occurred()) SWIG_fail;
9077 }
9078 Py_INCREF(Py_None); resultobj = Py_None;
9079 return resultobj;
9080 fail:
9081 return NULL;
9082 }
9083
9084
9085 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9086 PyObject *resultobj;
9087 wxArrayString *result;
9088 char *kwnames[] = {
9089 NULL
9090 };
9091
9092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9093 {
9094 PyThreadState* __tstate = wxPyBeginAllowThreads();
9095 {
9096 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9097 result = (wxArrayString *) &_result_ref;
9098 }
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 resultobj = wxArrayString2PyList_helper(*result);
9105 }
9106 return resultobj;
9107 fail:
9108 return NULL;
9109 }
9110
9111
9112 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9113 PyObject *resultobj;
9114 wxChar *arg1 = (wxChar *) 0 ;
9115 PyObject * obj0 = 0 ;
9116 char *kwnames[] = {
9117 (char *) "ts", NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9122 if (SWIG_arg_fail(1)) SWIG_fail;
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 wxLog::SetTimestamp((wxChar const *)arg1);
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 Py_INCREF(Py_None); resultobj = Py_None;
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 bool result;
9140 char *kwnames[] = {
9141 NULL
9142 };
9143
9144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9145 {
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (bool)wxLog::GetVerbose();
9148
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 {
9153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9154 }
9155 return resultobj;
9156 fail:
9157 return NULL;
9158 }
9159
9160
9161 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9162 PyObject *resultobj;
9163 wxTraceMask result;
9164 char *kwnames[] = {
9165 NULL
9166 };
9167
9168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9169 {
9170 PyThreadState* __tstate = wxPyBeginAllowThreads();
9171 result = (wxTraceMask)wxLog::GetTraceMask();
9172
9173 wxPyEndAllowThreads(__tstate);
9174 if (PyErr_Occurred()) SWIG_fail;
9175 }
9176 {
9177 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9178 }
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj;
9187 wxChar *arg1 = (wxChar *) 0 ;
9188 bool result;
9189 PyObject * obj0 = 0 ;
9190 char *kwnames[] = {
9191 (char *) "mask", NULL
9192 };
9193
9194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9196 if (SWIG_arg_fail(1)) SWIG_fail;
9197 {
9198 PyThreadState* __tstate = wxPyBeginAllowThreads();
9199 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9200
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 {
9205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9206 }
9207 return resultobj;
9208 fail:
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxLogLevel result;
9216 char *kwnames[] = {
9217 NULL
9218 };
9219
9220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9221 {
9222 PyThreadState* __tstate = wxPyBeginAllowThreads();
9223 result = (wxLogLevel)wxLog::GetLogLevel();
9224
9225 wxPyEndAllowThreads(__tstate);
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 {
9229 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9230 }
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9238 PyObject *resultobj;
9239 wxChar *result;
9240 char *kwnames[] = {
9241 NULL
9242 };
9243
9244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (wxChar *)wxLog::GetTimestamp();
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 wxString result;
9262 char *kwnames[] = {
9263 NULL
9264 };
9265
9266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9267 {
9268 PyThreadState* __tstate = wxPyBeginAllowThreads();
9269 result = Log_TimeStamp();
9270
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 {
9275 #if wxUSE_UNICODE
9276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9277 #else
9278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9279 #endif
9280 }
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9288 PyObject *resultobj;
9289 wxLog *arg1 = (wxLog *) 0 ;
9290 PyObject * obj0 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "self", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 wxLog_Destroy(arg1);
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 Py_INCREF(Py_None); resultobj = Py_None;
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9313 PyObject *obj;
9314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9315 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9316 Py_INCREF(obj);
9317 return Py_BuildValue((char *)"");
9318 }
9319 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9320 PyObject *resultobj;
9321 wxLogStderr *result;
9322 char *kwnames[] = {
9323 NULL
9324 };
9325
9326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9327 {
9328 PyThreadState* __tstate = wxPyBeginAllowThreads();
9329 result = (wxLogStderr *)new wxLogStderr();
9330
9331 wxPyEndAllowThreads(__tstate);
9332 if (PyErr_Occurred()) SWIG_fail;
9333 }
9334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9335 return resultobj;
9336 fail:
9337 return NULL;
9338 }
9339
9340
9341 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9342 PyObject *obj;
9343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9344 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9345 Py_INCREF(obj);
9346 return Py_BuildValue((char *)"");
9347 }
9348 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9349 PyObject *resultobj;
9350 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9351 wxLogTextCtrl *result;
9352 PyObject * obj0 = 0 ;
9353 char *kwnames[] = {
9354 (char *) "pTextCtrl", NULL
9355 };
9356
9357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(1)) SWIG_fail;
9360 {
9361 PyThreadState* __tstate = wxPyBeginAllowThreads();
9362 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9363
9364 wxPyEndAllowThreads(__tstate);
9365 if (PyErr_Occurred()) SWIG_fail;
9366 }
9367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9375 PyObject *obj;
9376 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9377 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9378 Py_INCREF(obj);
9379 return Py_BuildValue((char *)"");
9380 }
9381 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj;
9383 wxLogGui *result;
9384 char *kwnames[] = {
9385 NULL
9386 };
9387
9388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9389 {
9390 PyThreadState* __tstate = wxPyBeginAllowThreads();
9391 result = (wxLogGui *)new wxLogGui();
9392
9393 wxPyEndAllowThreads(__tstate);
9394 if (PyErr_Occurred()) SWIG_fail;
9395 }
9396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9397 return resultobj;
9398 fail:
9399 return NULL;
9400 }
9401
9402
9403 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9404 PyObject *obj;
9405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9406 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9407 Py_INCREF(obj);
9408 return Py_BuildValue((char *)"");
9409 }
9410 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj;
9412 wxFrame *arg1 = (wxFrame *) 0 ;
9413 wxString *arg2 = 0 ;
9414 bool arg3 = (bool) true ;
9415 bool arg4 = (bool) true ;
9416 wxLogWindow *result;
9417 bool temp2 = false ;
9418 PyObject * obj0 = 0 ;
9419 PyObject * obj1 = 0 ;
9420 PyObject * obj2 = 0 ;
9421 PyObject * obj3 = 0 ;
9422 char *kwnames[] = {
9423 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9424 };
9425
9426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9428 if (SWIG_arg_fail(1)) SWIG_fail;
9429 {
9430 arg2 = wxString_in_helper(obj1);
9431 if (arg2 == NULL) SWIG_fail;
9432 temp2 = true;
9433 }
9434 if (obj2) {
9435 {
9436 arg3 = (bool)(SWIG_As_bool(obj2));
9437 if (SWIG_arg_fail(3)) SWIG_fail;
9438 }
9439 }
9440 if (obj3) {
9441 {
9442 arg4 = (bool)(SWIG_As_bool(obj3));
9443 if (SWIG_arg_fail(4)) SWIG_fail;
9444 }
9445 }
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9454 {
9455 if (temp2)
9456 delete arg2;
9457 }
9458 return resultobj;
9459 fail:
9460 {
9461 if (temp2)
9462 delete arg2;
9463 }
9464 return NULL;
9465 }
9466
9467
9468 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9469 PyObject *resultobj;
9470 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9471 bool arg2 = (bool) true ;
9472 PyObject * obj0 = 0 ;
9473 PyObject * obj1 = 0 ;
9474 char *kwnames[] = {
9475 (char *) "self",(char *) "bShow", NULL
9476 };
9477
9478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9480 if (SWIG_arg_fail(1)) SWIG_fail;
9481 if (obj1) {
9482 {
9483 arg2 = (bool)(SWIG_As_bool(obj1));
9484 if (SWIG_arg_fail(2)) SWIG_fail;
9485 }
9486 }
9487 {
9488 PyThreadState* __tstate = wxPyBeginAllowThreads();
9489 (arg1)->Show(arg2);
9490
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 Py_INCREF(Py_None); resultobj = Py_None;
9495 return resultobj;
9496 fail:
9497 return NULL;
9498 }
9499
9500
9501 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9502 PyObject *resultobj;
9503 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9504 wxFrame *result;
9505 PyObject * obj0 = 0 ;
9506 char *kwnames[] = {
9507 (char *) "self", NULL
9508 };
9509
9510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9512 if (SWIG_arg_fail(1)) SWIG_fail;
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 {
9521 resultobj = wxPyMake_wxObject(result, 0);
9522 }
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9532 wxLog *result;
9533 PyObject * obj0 = 0 ;
9534 char *kwnames[] = {
9535 (char *) "self", NULL
9536 };
9537
9538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9540 if (SWIG_arg_fail(1)) SWIG_fail;
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9544
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj;
9557 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9558 bool result;
9559 PyObject * obj0 = 0 ;
9560 char *kwnames[] = {
9561 (char *) "self", NULL
9562 };
9563
9564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9566 if (SWIG_arg_fail(1)) SWIG_fail;
9567 {
9568 PyThreadState* __tstate = wxPyBeginAllowThreads();
9569 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9570
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 {
9575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9576 }
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj;
9585 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9586 bool arg2 ;
9587 PyObject * obj0 = 0 ;
9588 PyObject * obj1 = 0 ;
9589 char *kwnames[] = {
9590 (char *) "self",(char *) "bDoPass", NULL
9591 };
9592
9593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9595 if (SWIG_arg_fail(1)) SWIG_fail;
9596 {
9597 arg2 = (bool)(SWIG_As_bool(obj1));
9598 if (SWIG_arg_fail(2)) SWIG_fail;
9599 }
9600 {
9601 PyThreadState* __tstate = wxPyBeginAllowThreads();
9602 (arg1)->PassMessages(arg2);
9603
9604 wxPyEndAllowThreads(__tstate);
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 Py_INCREF(Py_None); resultobj = Py_None;
9608 return resultobj;
9609 fail:
9610 return NULL;
9611 }
9612
9613
9614 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9615 PyObject *obj;
9616 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9617 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9618 Py_INCREF(obj);
9619 return Py_BuildValue((char *)"");
9620 }
9621 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9622 PyObject *resultobj;
9623 wxLog *arg1 = (wxLog *) 0 ;
9624 wxLogChain *result;
9625 PyObject * obj0 = 0 ;
9626 char *kwnames[] = {
9627 (char *) "logger", NULL
9628 };
9629
9630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9632 if (SWIG_arg_fail(1)) SWIG_fail;
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (wxLogChain *)new wxLogChain(arg1);
9636
9637 wxPyEndAllowThreads(__tstate);
9638 if (PyErr_Occurred()) SWIG_fail;
9639 }
9640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9641 return resultobj;
9642 fail:
9643 return NULL;
9644 }
9645
9646
9647 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9648 PyObject *resultobj;
9649 wxLogChain *arg1 = (wxLogChain *) 0 ;
9650 wxLog *arg2 = (wxLog *) 0 ;
9651 PyObject * obj0 = 0 ;
9652 PyObject * obj1 = 0 ;
9653 char *kwnames[] = {
9654 (char *) "self",(char *) "logger", NULL
9655 };
9656
9657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9659 if (SWIG_arg_fail(1)) SWIG_fail;
9660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9661 if (SWIG_arg_fail(2)) SWIG_fail;
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 (arg1)->SetLog(arg2);
9665
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 Py_INCREF(Py_None); resultobj = Py_None;
9670 return resultobj;
9671 fail:
9672 return NULL;
9673 }
9674
9675
9676 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9677 PyObject *resultobj;
9678 wxLogChain *arg1 = (wxLogChain *) 0 ;
9679 bool arg2 ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 char *kwnames[] = {
9683 (char *) "self",(char *) "bDoPass", NULL
9684 };
9685
9686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9688 if (SWIG_arg_fail(1)) SWIG_fail;
9689 {
9690 arg2 = (bool)(SWIG_As_bool(obj1));
9691 if (SWIG_arg_fail(2)) SWIG_fail;
9692 }
9693 {
9694 PyThreadState* __tstate = wxPyBeginAllowThreads();
9695 (arg1)->PassMessages(arg2);
9696
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 Py_INCREF(Py_None); resultobj = Py_None;
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj;
9709 wxLogChain *arg1 = (wxLogChain *) 0 ;
9710 bool result;
9711 PyObject * obj0 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "self", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(1)) SWIG_fail;
9719 {
9720 PyThreadState* __tstate = wxPyBeginAllowThreads();
9721 result = (bool)(arg1)->IsPassingMessages();
9722
9723 wxPyEndAllowThreads(__tstate);
9724 if (PyErr_Occurred()) SWIG_fail;
9725 }
9726 {
9727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9728 }
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9736 PyObject *resultobj;
9737 wxLogChain *arg1 = (wxLogChain *) 0 ;
9738 wxLog *result;
9739 PyObject * obj0 = 0 ;
9740 char *kwnames[] = {
9741 (char *) "self", NULL
9742 };
9743
9744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9746 if (SWIG_arg_fail(1)) SWIG_fail;
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 result = (wxLog *)(arg1)->GetOldLog();
9750
9751 wxPyEndAllowThreads(__tstate);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9755 return resultobj;
9756 fail:
9757 return NULL;
9758 }
9759
9760
9761 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9762 PyObject *obj;
9763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9764 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9765 Py_INCREF(obj);
9766 return Py_BuildValue((char *)"");
9767 }
9768 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9769 PyObject *resultobj;
9770 unsigned long result;
9771 char *kwnames[] = {
9772 NULL
9773 };
9774
9775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9776 {
9777 PyThreadState* __tstate = wxPyBeginAllowThreads();
9778 result = (unsigned long)wxSysErrorCode();
9779
9780 wxPyEndAllowThreads(__tstate);
9781 if (PyErr_Occurred()) SWIG_fail;
9782 }
9783 {
9784 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9785 }
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9793 PyObject *resultobj;
9794 unsigned long arg1 = (unsigned long) 0 ;
9795 wxString result;
9796 PyObject * obj0 = 0 ;
9797 char *kwnames[] = {
9798 (char *) "nErrCode", NULL
9799 };
9800
9801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9802 if (obj0) {
9803 {
9804 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9805 if (SWIG_arg_fail(1)) SWIG_fail;
9806 }
9807 }
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = wxSysErrorMsg(arg1);
9811
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj;
9830 wxString *arg1 = 0 ;
9831 bool temp1 = false ;
9832 PyObject * obj0 = 0 ;
9833 char *kwnames[] = {
9834 (char *) "msg", NULL
9835 };
9836
9837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9838 {
9839 arg1 = wxString_in_helper(obj0);
9840 if (arg1 == NULL) SWIG_fail;
9841 temp1 = true;
9842 }
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 wxPyLogFatalError((wxString const &)*arg1);
9846
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 Py_INCREF(Py_None); resultobj = Py_None;
9851 {
9852 if (temp1)
9853 delete arg1;
9854 }
9855 return resultobj;
9856 fail:
9857 {
9858 if (temp1)
9859 delete arg1;
9860 }
9861 return NULL;
9862 }
9863
9864
9865 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj;
9867 wxString *arg1 = 0 ;
9868 bool temp1 = false ;
9869 PyObject * obj0 = 0 ;
9870 char *kwnames[] = {
9871 (char *) "msg", NULL
9872 };
9873
9874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9875 {
9876 arg1 = wxString_in_helper(obj0);
9877 if (arg1 == NULL) SWIG_fail;
9878 temp1 = true;
9879 }
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 wxPyLogError((wxString const &)*arg1);
9883
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 Py_INCREF(Py_None); resultobj = Py_None;
9888 {
9889 if (temp1)
9890 delete arg1;
9891 }
9892 return resultobj;
9893 fail:
9894 {
9895 if (temp1)
9896 delete arg1;
9897 }
9898 return NULL;
9899 }
9900
9901
9902 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj;
9904 wxString *arg1 = 0 ;
9905 bool temp1 = false ;
9906 PyObject * obj0 = 0 ;
9907 char *kwnames[] = {
9908 (char *) "msg", NULL
9909 };
9910
9911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9912 {
9913 arg1 = wxString_in_helper(obj0);
9914 if (arg1 == NULL) SWIG_fail;
9915 temp1 = true;
9916 }
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 wxPyLogWarning((wxString const &)*arg1);
9920
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 Py_INCREF(Py_None); resultobj = Py_None;
9925 {
9926 if (temp1)
9927 delete arg1;
9928 }
9929 return resultobj;
9930 fail:
9931 {
9932 if (temp1)
9933 delete arg1;
9934 }
9935 return NULL;
9936 }
9937
9938
9939 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9940 PyObject *resultobj;
9941 wxString *arg1 = 0 ;
9942 bool temp1 = false ;
9943 PyObject * obj0 = 0 ;
9944 char *kwnames[] = {
9945 (char *) "msg", NULL
9946 };
9947
9948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9949 {
9950 arg1 = wxString_in_helper(obj0);
9951 if (arg1 == NULL) SWIG_fail;
9952 temp1 = true;
9953 }
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 wxPyLogMessage((wxString const &)*arg1);
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 Py_INCREF(Py_None); resultobj = Py_None;
9962 {
9963 if (temp1)
9964 delete arg1;
9965 }
9966 return resultobj;
9967 fail:
9968 {
9969 if (temp1)
9970 delete arg1;
9971 }
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj;
9978 wxString *arg1 = 0 ;
9979 bool temp1 = false ;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "msg", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9986 {
9987 arg1 = wxString_in_helper(obj0);
9988 if (arg1 == NULL) SWIG_fail;
9989 temp1 = true;
9990 }
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 wxPyLogInfo((wxString const &)*arg1);
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 Py_INCREF(Py_None); resultobj = Py_None;
9999 {
10000 if (temp1)
10001 delete arg1;
10002 }
10003 return resultobj;
10004 fail:
10005 {
10006 if (temp1)
10007 delete arg1;
10008 }
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxString *arg1 = 0 ;
10016 bool temp1 = false ;
10017 PyObject * obj0 = 0 ;
10018 char *kwnames[] = {
10019 (char *) "msg", NULL
10020 };
10021
10022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10023 {
10024 arg1 = wxString_in_helper(obj0);
10025 if (arg1 == NULL) SWIG_fail;
10026 temp1 = true;
10027 }
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 wxPyLogDebug((wxString const &)*arg1);
10031
10032 wxPyEndAllowThreads(__tstate);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 Py_INCREF(Py_None); resultobj = Py_None;
10036 {
10037 if (temp1)
10038 delete arg1;
10039 }
10040 return resultobj;
10041 fail:
10042 {
10043 if (temp1)
10044 delete arg1;
10045 }
10046 return NULL;
10047 }
10048
10049
10050 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10051 PyObject *resultobj;
10052 wxString *arg1 = 0 ;
10053 bool temp1 = false ;
10054 PyObject * obj0 = 0 ;
10055 char *kwnames[] = {
10056 (char *) "msg", NULL
10057 };
10058
10059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10060 {
10061 arg1 = wxString_in_helper(obj0);
10062 if (arg1 == NULL) SWIG_fail;
10063 temp1 = true;
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 wxPyLogVerbose((wxString const &)*arg1);
10068
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 Py_INCREF(Py_None); resultobj = Py_None;
10073 {
10074 if (temp1)
10075 delete arg1;
10076 }
10077 return resultobj;
10078 fail:
10079 {
10080 if (temp1)
10081 delete arg1;
10082 }
10083 return NULL;
10084 }
10085
10086
10087 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj;
10089 wxString *arg1 = 0 ;
10090 bool temp1 = false ;
10091 PyObject * obj0 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "msg", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10097 {
10098 arg1 = wxString_in_helper(obj0);
10099 if (arg1 == NULL) SWIG_fail;
10100 temp1 = true;
10101 }
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 wxPyLogStatus((wxString const &)*arg1);
10105
10106 wxPyEndAllowThreads(__tstate);
10107 if (PyErr_Occurred()) SWIG_fail;
10108 }
10109 Py_INCREF(Py_None); resultobj = Py_None;
10110 {
10111 if (temp1)
10112 delete arg1;
10113 }
10114 return resultobj;
10115 fail:
10116 {
10117 if (temp1)
10118 delete arg1;
10119 }
10120 return NULL;
10121 }
10122
10123
10124 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj;
10126 wxFrame *arg1 = (wxFrame *) 0 ;
10127 wxString *arg2 = 0 ;
10128 bool temp2 = false ;
10129 PyObject * obj0 = 0 ;
10130 PyObject * obj1 = 0 ;
10131 char *kwnames[] = {
10132 (char *) "pFrame",(char *) "msg", NULL
10133 };
10134
10135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10137 if (SWIG_arg_fail(1)) SWIG_fail;
10138 {
10139 arg2 = wxString_in_helper(obj1);
10140 if (arg2 == NULL) SWIG_fail;
10141 temp2 = true;
10142 }
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10146
10147 wxPyEndAllowThreads(__tstate);
10148 if (PyErr_Occurred()) SWIG_fail;
10149 }
10150 Py_INCREF(Py_None); resultobj = Py_None;
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return resultobj;
10156 fail:
10157 {
10158 if (temp2)
10159 delete arg2;
10160 }
10161 return NULL;
10162 }
10163
10164
10165 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10166 PyObject *resultobj;
10167 wxString *arg1 = 0 ;
10168 bool temp1 = false ;
10169 PyObject * obj0 = 0 ;
10170 char *kwnames[] = {
10171 (char *) "msg", NULL
10172 };
10173
10174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10175 {
10176 arg1 = wxString_in_helper(obj0);
10177 if (arg1 == NULL) SWIG_fail;
10178 temp1 = true;
10179 }
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 wxPyLogSysError((wxString const &)*arg1);
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 Py_INCREF(Py_None); resultobj = Py_None;
10188 {
10189 if (temp1)
10190 delete arg1;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp1)
10196 delete arg1;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj;
10204 unsigned long arg1 ;
10205 wxString *arg2 = 0 ;
10206 bool temp2 = false ;
10207 PyObject * obj0 = 0 ;
10208 PyObject * obj1 = 0 ;
10209 char *kwnames[] = {
10210 (char *) "level",(char *) "msg", NULL
10211 };
10212
10213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10214 {
10215 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10216 if (SWIG_arg_fail(1)) SWIG_fail;
10217 }
10218 {
10219 arg2 = wxString_in_helper(obj1);
10220 if (arg2 == NULL) SWIG_fail;
10221 temp2 = true;
10222 }
10223 {
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10226
10227 wxPyEndAllowThreads(__tstate);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 Py_INCREF(Py_None); resultobj = Py_None;
10231 {
10232 if (temp2)
10233 delete arg2;
10234 }
10235 return resultobj;
10236 fail:
10237 {
10238 if (temp2)
10239 delete arg2;
10240 }
10241 return NULL;
10242 }
10243
10244
10245 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10246 PyObject *resultobj;
10247 unsigned long arg1 ;
10248 wxString *arg2 = 0 ;
10249 bool temp2 = false ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252
10253 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10254 {
10255 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10256 if (SWIG_arg_fail(1)) SWIG_fail;
10257 }
10258 {
10259 arg2 = wxString_in_helper(obj1);
10260 if (arg2 == NULL) SWIG_fail;
10261 temp2 = true;
10262 }
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 wxPyLogTrace(arg1,(wxString const &)*arg2);
10266
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 Py_INCREF(Py_None); resultobj = Py_None;
10271 {
10272 if (temp2)
10273 delete arg2;
10274 }
10275 return resultobj;
10276 fail:
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return NULL;
10282 }
10283
10284
10285 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10286 PyObject *resultobj;
10287 wxString *arg1 = 0 ;
10288 wxString *arg2 = 0 ;
10289 bool temp1 = false ;
10290 bool temp2 = false ;
10291 PyObject * obj0 = 0 ;
10292 PyObject * obj1 = 0 ;
10293
10294 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10295 {
10296 arg1 = wxString_in_helper(obj0);
10297 if (arg1 == NULL) SWIG_fail;
10298 temp1 = true;
10299 }
10300 {
10301 arg2 = wxString_in_helper(obj1);
10302 if (arg2 == NULL) SWIG_fail;
10303 temp2 = true;
10304 }
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10308
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 Py_INCREF(Py_None); resultobj = Py_None;
10313 {
10314 if (temp1)
10315 delete arg1;
10316 }
10317 {
10318 if (temp2)
10319 delete arg2;
10320 }
10321 return resultobj;
10322 fail:
10323 {
10324 if (temp1)
10325 delete arg1;
10326 }
10327 {
10328 if (temp2)
10329 delete arg2;
10330 }
10331 return NULL;
10332 }
10333
10334
10335 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10336 int argc;
10337 PyObject *argv[3];
10338 int ii;
10339
10340 argc = PyObject_Length(args);
10341 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10342 argv[ii] = PyTuple_GetItem(args,ii);
10343 }
10344 if (argc == 2) {
10345 int _v;
10346 {
10347 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10348 }
10349 if (_v) {
10350 {
10351 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10352 }
10353 if (_v) {
10354 return _wrap_LogTrace__SWIG_1(self,args);
10355 }
10356 }
10357 }
10358 if (argc == 2) {
10359 int _v;
10360 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10361 if (_v) {
10362 {
10363 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10364 }
10365 if (_v) {
10366 return _wrap_LogTrace__SWIG_0(self,args);
10367 }
10368 }
10369 }
10370
10371 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10372 return NULL;
10373 }
10374
10375
10376 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10377 PyObject *resultobj;
10378 wxString *arg1 = 0 ;
10379 wxString *arg2 = 0 ;
10380 bool temp1 = false ;
10381 bool temp2 = false ;
10382 PyObject * obj0 = 0 ;
10383 PyObject * obj1 = 0 ;
10384 char *kwnames[] = {
10385 (char *) "title",(char *) "text", NULL
10386 };
10387
10388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10389 {
10390 arg1 = wxString_in_helper(obj0);
10391 if (arg1 == NULL) SWIG_fail;
10392 temp1 = true;
10393 }
10394 {
10395 arg2 = wxString_in_helper(obj1);
10396 if (arg2 == NULL) SWIG_fail;
10397 temp2 = true;
10398 }
10399 {
10400 PyThreadState* __tstate = wxPyBeginAllowThreads();
10401 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10402
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 Py_INCREF(Py_None); resultobj = Py_None;
10407 {
10408 if (temp1)
10409 delete arg1;
10410 }
10411 {
10412 if (temp2)
10413 delete arg2;
10414 }
10415 return resultobj;
10416 fail:
10417 {
10418 if (temp1)
10419 delete arg1;
10420 }
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return NULL;
10426 }
10427
10428
10429 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10430 PyObject *resultobj;
10431 wxLogNull *result;
10432 char *kwnames[] = {
10433 NULL
10434 };
10435
10436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (wxLogNull *)new wxLogNull();
10440
10441 wxPyEndAllowThreads(__tstate);
10442 if (PyErr_Occurred()) SWIG_fail;
10443 }
10444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10445 return resultobj;
10446 fail:
10447 return NULL;
10448 }
10449
10450
10451 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10452 PyObject *resultobj;
10453 wxLogNull *arg1 = (wxLogNull *) 0 ;
10454 PyObject * obj0 = 0 ;
10455 char *kwnames[] = {
10456 (char *) "self", NULL
10457 };
10458
10459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10461 if (SWIG_arg_fail(1)) SWIG_fail;
10462 {
10463 PyThreadState* __tstate = wxPyBeginAllowThreads();
10464 delete arg1;
10465
10466 wxPyEndAllowThreads(__tstate);
10467 if (PyErr_Occurred()) SWIG_fail;
10468 }
10469 Py_INCREF(Py_None); resultobj = Py_None;
10470 return resultobj;
10471 fail:
10472 return NULL;
10473 }
10474
10475
10476 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10477 PyObject *obj;
10478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10479 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10480 Py_INCREF(obj);
10481 return Py_BuildValue((char *)"");
10482 }
10483 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10484 PyObject *resultobj;
10485 wxPyLog *result;
10486 char *kwnames[] = {
10487 NULL
10488 };
10489
10490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10491 {
10492 PyThreadState* __tstate = wxPyBeginAllowThreads();
10493 result = (wxPyLog *)new wxPyLog();
10494
10495 wxPyEndAllowThreads(__tstate);
10496 if (PyErr_Occurred()) SWIG_fail;
10497 }
10498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10499 return resultobj;
10500 fail:
10501 return NULL;
10502 }
10503
10504
10505 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10506 PyObject *resultobj;
10507 wxPyLog *arg1 = (wxPyLog *) 0 ;
10508 PyObject *arg2 = (PyObject *) 0 ;
10509 PyObject *arg3 = (PyObject *) 0 ;
10510 PyObject * obj0 = 0 ;
10511 PyObject * obj1 = 0 ;
10512 PyObject * obj2 = 0 ;
10513 char *kwnames[] = {
10514 (char *) "self",(char *) "self",(char *) "_class", NULL
10515 };
10516
10517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10519 if (SWIG_arg_fail(1)) SWIG_fail;
10520 arg2 = obj1;
10521 arg3 = obj2;
10522 {
10523 PyThreadState* __tstate = wxPyBeginAllowThreads();
10524 (arg1)->_setCallbackInfo(arg2,arg3);
10525
10526 wxPyEndAllowThreads(__tstate);
10527 if (PyErr_Occurred()) SWIG_fail;
10528 }
10529 Py_INCREF(Py_None); resultobj = Py_None;
10530 return resultobj;
10531 fail:
10532 return NULL;
10533 }
10534
10535
10536 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10537 PyObject *obj;
10538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10539 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10540 Py_INCREF(obj);
10541 return Py_BuildValue((char *)"");
10542 }
10543 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10544 PyObject *resultobj;
10545 int arg1 ;
10546 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10547 int arg3 = (int) wxKILL_NOCHILDREN ;
10548 wxKillError result;
10549 PyObject * obj0 = 0 ;
10550 PyObject * obj1 = 0 ;
10551 PyObject * obj2 = 0 ;
10552 char *kwnames[] = {
10553 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10554 };
10555
10556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10557 {
10558 arg1 = (int)(SWIG_As_int(obj0));
10559 if (SWIG_arg_fail(1)) SWIG_fail;
10560 }
10561 if (obj1) {
10562 {
10563 arg2 = (wxSignal)(SWIG_As_int(obj1));
10564 if (SWIG_arg_fail(2)) SWIG_fail;
10565 }
10566 }
10567 if (obj2) {
10568 {
10569 arg3 = (int)(SWIG_As_int(obj2));
10570 if (SWIG_arg_fail(3)) SWIG_fail;
10571 }
10572 }
10573 {
10574 PyThreadState* __tstate = wxPyBeginAllowThreads();
10575 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10576
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_From_int((result));
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj;
10589 int arg1 ;
10590 bool result;
10591 PyObject * obj0 = 0 ;
10592 char *kwnames[] = {
10593 (char *) "pid", NULL
10594 };
10595
10596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10597 {
10598 arg1 = (int)(SWIG_As_int(obj0));
10599 if (SWIG_arg_fail(1)) SWIG_fail;
10600 }
10601 {
10602 PyThreadState* __tstate = wxPyBeginAllowThreads();
10603 result = (bool)wxPyProcess::Exists(arg1);
10604
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 {
10609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10610 }
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10618 PyObject *resultobj;
10619 wxString *arg1 = 0 ;
10620 int arg2 = (int) wxEXEC_ASYNC ;
10621 wxPyProcess *result;
10622 bool temp1 = false ;
10623 PyObject * obj0 = 0 ;
10624 PyObject * obj1 = 0 ;
10625 char *kwnames[] = {
10626 (char *) "cmd",(char *) "flags", NULL
10627 };
10628
10629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10630 {
10631 arg1 = wxString_in_helper(obj0);
10632 if (arg1 == NULL) SWIG_fail;
10633 temp1 = true;
10634 }
10635 if (obj1) {
10636 {
10637 arg2 = (int)(SWIG_As_int(obj1));
10638 if (SWIG_arg_fail(2)) SWIG_fail;
10639 }
10640 }
10641 {
10642 PyThreadState* __tstate = wxPyBeginAllowThreads();
10643 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10644
10645 wxPyEndAllowThreads(__tstate);
10646 if (PyErr_Occurred()) SWIG_fail;
10647 }
10648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10649 {
10650 if (temp1)
10651 delete arg1;
10652 }
10653 return resultobj;
10654 fail:
10655 {
10656 if (temp1)
10657 delete arg1;
10658 }
10659 return NULL;
10660 }
10661
10662
10663 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10664 PyObject *resultobj;
10665 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10666 int arg2 = (int) -1 ;
10667 wxPyProcess *result;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 char *kwnames[] = {
10671 (char *) "parent",(char *) "id", NULL
10672 };
10673
10674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10675 if (obj0) {
10676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10677 if (SWIG_arg_fail(1)) SWIG_fail;
10678 }
10679 if (obj1) {
10680 {
10681 arg2 = (int)(SWIG_As_int(obj1));
10682 if (SWIG_arg_fail(2)) SWIG_fail;
10683 }
10684 }
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10688
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10693 return resultobj;
10694 fail:
10695 return NULL;
10696 }
10697
10698
10699 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj;
10701 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10702 PyObject *arg2 = (PyObject *) 0 ;
10703 PyObject *arg3 = (PyObject *) 0 ;
10704 PyObject * obj0 = 0 ;
10705 PyObject * obj1 = 0 ;
10706 PyObject * obj2 = 0 ;
10707 char *kwnames[] = {
10708 (char *) "self",(char *) "self",(char *) "_class", NULL
10709 };
10710
10711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10713 if (SWIG_arg_fail(1)) SWIG_fail;
10714 arg2 = obj1;
10715 arg3 = obj2;
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 (arg1)->_setCallbackInfo(arg2,arg3);
10719
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 Py_INCREF(Py_None); resultobj = Py_None;
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj;
10732 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10733 int arg2 ;
10734 int arg3 ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 PyObject * obj2 = 0 ;
10738 char *kwnames[] = {
10739 (char *) "self",(char *) "pid",(char *) "status", NULL
10740 };
10741
10742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10744 if (SWIG_arg_fail(1)) SWIG_fail;
10745 {
10746 arg2 = (int)(SWIG_As_int(obj1));
10747 if (SWIG_arg_fail(2)) SWIG_fail;
10748 }
10749 {
10750 arg3 = (int)(SWIG_As_int(obj2));
10751 if (SWIG_arg_fail(3)) SWIG_fail;
10752 }
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 (arg1)->base_OnTerminate(arg2,arg3);
10756
10757 wxPyEndAllowThreads(__tstate);
10758 if (PyErr_Occurred()) SWIG_fail;
10759 }
10760 Py_INCREF(Py_None); resultobj = Py_None;
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj;
10769 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10770 PyObject * obj0 = 0 ;
10771 char *kwnames[] = {
10772 (char *) "self", NULL
10773 };
10774
10775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10777 if (SWIG_arg_fail(1)) SWIG_fail;
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 (arg1)->Redirect();
10781
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 Py_INCREF(Py_None); resultobj = Py_None;
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj;
10794 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10795 bool result;
10796 PyObject * obj0 = 0 ;
10797 char *kwnames[] = {
10798 (char *) "self", NULL
10799 };
10800
10801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10803 if (SWIG_arg_fail(1)) SWIG_fail;
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = (bool)(arg1)->IsRedirected();
10807
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 {
10812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10813 }
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj;
10822 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10823 PyObject * obj0 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "self", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10830 if (SWIG_arg_fail(1)) SWIG_fail;
10831 {
10832 PyThreadState* __tstate = wxPyBeginAllowThreads();
10833 (arg1)->Detach();
10834
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 Py_INCREF(Py_None); resultobj = Py_None;
10839 return resultobj;
10840 fail:
10841 return NULL;
10842 }
10843
10844
10845 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10846 PyObject *resultobj;
10847 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10848 wxInputStream *result;
10849 PyObject * obj0 = 0 ;
10850 char *kwnames[] = {
10851 (char *) "self", NULL
10852 };
10853
10854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10856 if (SWIG_arg_fail(1)) SWIG_fail;
10857 {
10858 PyThreadState* __tstate = wxPyBeginAllowThreads();
10859 result = (wxInputStream *)(arg1)->GetInputStream();
10860
10861 wxPyEndAllowThreads(__tstate);
10862 if (PyErr_Occurred()) SWIG_fail;
10863 }
10864 {
10865 wxPyInputStream * _ptr = NULL;
10866
10867 if (result) {
10868 _ptr = new wxPyInputStream(result);
10869 }
10870 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10871 }
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10879 PyObject *resultobj;
10880 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10881 wxInputStream *result;
10882 PyObject * obj0 = 0 ;
10883 char *kwnames[] = {
10884 (char *) "self", NULL
10885 };
10886
10887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 result = (wxInputStream *)(arg1)->GetErrorStream();
10893
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 {
10898 wxPyInputStream * _ptr = NULL;
10899
10900 if (result) {
10901 _ptr = new wxPyInputStream(result);
10902 }
10903 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10904 }
10905 return resultobj;
10906 fail:
10907 return NULL;
10908 }
10909
10910
10911 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10912 PyObject *resultobj;
10913 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10914 wxOutputStream *result;
10915 PyObject * obj0 = 0 ;
10916 char *kwnames[] = {
10917 (char *) "self", NULL
10918 };
10919
10920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10922 if (SWIG_arg_fail(1)) SWIG_fail;
10923 {
10924 PyThreadState* __tstate = wxPyBeginAllowThreads();
10925 result = (wxOutputStream *)(arg1)->GetOutputStream();
10926
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10931 return resultobj;
10932 fail:
10933 return NULL;
10934 }
10935
10936
10937 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj;
10939 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10940 PyObject * obj0 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 {
10949 PyThreadState* __tstate = wxPyBeginAllowThreads();
10950 (arg1)->CloseOutput();
10951
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 Py_INCREF(Py_None); resultobj = Py_None;
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj;
10964 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10965 bool result;
10966 PyObject * obj0 = 0 ;
10967 char *kwnames[] = {
10968 (char *) "self", NULL
10969 };
10970
10971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10973 if (SWIG_arg_fail(1)) SWIG_fail;
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10977
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10983 }
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10993 bool result;
10994 PyObject * obj0 = 0 ;
10995 char *kwnames[] = {
10996 (char *) "self", NULL
10997 };
10998
10999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11001 if (SWIG_arg_fail(1)) SWIG_fail;
11002 {
11003 PyThreadState* __tstate = wxPyBeginAllowThreads();
11004 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11005
11006 wxPyEndAllowThreads(__tstate);
11007 if (PyErr_Occurred()) SWIG_fail;
11008 }
11009 {
11010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11011 }
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj;
11020 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11021 bool result;
11022 PyObject * obj0 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11033
11034 wxPyEndAllowThreads(__tstate);
11035 if (PyErr_Occurred()) SWIG_fail;
11036 }
11037 {
11038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11039 }
11040 return resultobj;
11041 fail:
11042 return NULL;
11043 }
11044
11045
11046 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11047 PyObject *obj;
11048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11049 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11050 Py_INCREF(obj);
11051 return Py_BuildValue((char *)"");
11052 }
11053 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11054 PyObject *resultobj;
11055 int arg1 = (int) 0 ;
11056 int arg2 = (int) 0 ;
11057 int arg3 = (int) 0 ;
11058 wxProcessEvent *result;
11059 PyObject * obj0 = 0 ;
11060 PyObject * obj1 = 0 ;
11061 PyObject * obj2 = 0 ;
11062 char *kwnames[] = {
11063 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11064 };
11065
11066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11067 if (obj0) {
11068 {
11069 arg1 = (int)(SWIG_As_int(obj0));
11070 if (SWIG_arg_fail(1)) SWIG_fail;
11071 }
11072 }
11073 if (obj1) {
11074 {
11075 arg2 = (int)(SWIG_As_int(obj1));
11076 if (SWIG_arg_fail(2)) SWIG_fail;
11077 }
11078 }
11079 if (obj2) {
11080 {
11081 arg3 = (int)(SWIG_As_int(obj2));
11082 if (SWIG_arg_fail(3)) SWIG_fail;
11083 }
11084 }
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11088
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj;
11101 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11102 int result;
11103 PyObject * obj0 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "self", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11110 if (SWIG_arg_fail(1)) SWIG_fail;
11111 {
11112 PyThreadState* __tstate = wxPyBeginAllowThreads();
11113 result = (int)(arg1)->GetPid();
11114
11115 wxPyEndAllowThreads(__tstate);
11116 if (PyErr_Occurred()) SWIG_fail;
11117 }
11118 {
11119 resultobj = SWIG_From_int((int)(result));
11120 }
11121 return resultobj;
11122 fail:
11123 return NULL;
11124 }
11125
11126
11127 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11128 PyObject *resultobj;
11129 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11130 int result;
11131 PyObject * obj0 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "self", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11138 if (SWIG_arg_fail(1)) SWIG_fail;
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 result = (int)(arg1)->GetExitCode();
11142
11143 wxPyEndAllowThreads(__tstate);
11144 if (PyErr_Occurred()) SWIG_fail;
11145 }
11146 {
11147 resultobj = SWIG_From_int((int)(result));
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11158 int arg2 ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 char *kwnames[] = {
11162 (char *) "self",(char *) "m_pid", NULL
11163 };
11164
11165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11167 if (SWIG_arg_fail(1)) SWIG_fail;
11168 {
11169 arg2 = (int)(SWIG_As_int(obj1));
11170 if (SWIG_arg_fail(2)) SWIG_fail;
11171 }
11172 if (arg1) (arg1)->m_pid = arg2;
11173
11174 Py_INCREF(Py_None); resultobj = Py_None;
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11182 PyObject *resultobj;
11183 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11184 int result;
11185 PyObject * obj0 = 0 ;
11186 char *kwnames[] = {
11187 (char *) "self", NULL
11188 };
11189
11190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11192 if (SWIG_arg_fail(1)) SWIG_fail;
11193 result = (int) ((arg1)->m_pid);
11194
11195 {
11196 resultobj = SWIG_From_int((int)(result));
11197 }
11198 return resultobj;
11199 fail:
11200 return NULL;
11201 }
11202
11203
11204 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11205 PyObject *resultobj;
11206 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11207 int arg2 ;
11208 PyObject * obj0 = 0 ;
11209 PyObject * obj1 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self",(char *) "m_exitcode", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 arg2 = (int)(SWIG_As_int(obj1));
11219 if (SWIG_arg_fail(2)) SWIG_fail;
11220 }
11221 if (arg1) (arg1)->m_exitcode = arg2;
11222
11223 Py_INCREF(Py_None); resultobj = Py_None;
11224 return resultobj;
11225 fail:
11226 return NULL;
11227 }
11228
11229
11230 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11231 PyObject *resultobj;
11232 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11233 int result;
11234 PyObject * obj0 = 0 ;
11235 char *kwnames[] = {
11236 (char *) "self", NULL
11237 };
11238
11239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11241 if (SWIG_arg_fail(1)) SWIG_fail;
11242 result = (int) ((arg1)->m_exitcode);
11243
11244 {
11245 resultobj = SWIG_From_int((int)(result));
11246 }
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11254 PyObject *obj;
11255 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11256 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11257 Py_INCREF(obj);
11258 return Py_BuildValue((char *)"");
11259 }
11260 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj;
11262 wxString *arg1 = 0 ;
11263 int arg2 = (int) wxEXEC_ASYNC ;
11264 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11265 long result;
11266 bool temp1 = false ;
11267 PyObject * obj0 = 0 ;
11268 PyObject * obj1 = 0 ;
11269 PyObject * obj2 = 0 ;
11270 char *kwnames[] = {
11271 (char *) "command",(char *) "flags",(char *) "process", NULL
11272 };
11273
11274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11275 {
11276 arg1 = wxString_in_helper(obj0);
11277 if (arg1 == NULL) SWIG_fail;
11278 temp1 = true;
11279 }
11280 if (obj1) {
11281 {
11282 arg2 = (int)(SWIG_As_int(obj1));
11283 if (SWIG_arg_fail(2)) SWIG_fail;
11284 }
11285 }
11286 if (obj2) {
11287 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11288 if (SWIG_arg_fail(3)) SWIG_fail;
11289 }
11290 {
11291 if (!wxPyCheckForApp()) SWIG_fail;
11292 PyThreadState* __tstate = wxPyBeginAllowThreads();
11293 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11294
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 {
11299 resultobj = SWIG_From_long((long)(result));
11300 }
11301 {
11302 if (temp1)
11303 delete arg1;
11304 }
11305 return resultobj;
11306 fail:
11307 {
11308 if (temp1)
11309 delete arg1;
11310 }
11311 return NULL;
11312 }
11313
11314
11315 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj;
11317 long arg1 ;
11318 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11319 wxKillError *arg3 = (wxKillError *) 0 ;
11320 int arg4 = (int) wxKILL_NOCHILDREN ;
11321 int result;
11322 wxKillError temp3 ;
11323 PyObject * obj0 = 0 ;
11324 PyObject * obj1 = 0 ;
11325 PyObject * obj2 = 0 ;
11326 char *kwnames[] = {
11327 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11328 };
11329
11330 {
11331 arg3 = &temp3;
11332 }
11333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11334 {
11335 arg1 = (long)(SWIG_As_long(obj0));
11336 if (SWIG_arg_fail(1)) SWIG_fail;
11337 }
11338 if (obj1) {
11339 {
11340 arg2 = (wxSignal)(SWIG_As_int(obj1));
11341 if (SWIG_arg_fail(2)) SWIG_fail;
11342 }
11343 }
11344 if (obj2) {
11345 {
11346 arg4 = (int)(SWIG_As_int(obj2));
11347 if (SWIG_arg_fail(4)) SWIG_fail;
11348 }
11349 }
11350 {
11351 PyThreadState* __tstate = wxPyBeginAllowThreads();
11352 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11353
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 {
11358 resultobj = SWIG_From_int((int)(result));
11359 }
11360 {
11361 PyObject* o;
11362 o = PyInt_FromLong((long) (*arg3));
11363 resultobj = t_output_helper(resultobj, o);
11364 }
11365 return resultobj;
11366 fail:
11367 return NULL;
11368 }
11369
11370
11371 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj;
11373 int arg1 = (int) wxJOYSTICK1 ;
11374 wxJoystick *result;
11375 PyObject * obj0 = 0 ;
11376 char *kwnames[] = {
11377 (char *) "joystick", NULL
11378 };
11379
11380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11381 if (obj0) {
11382 {
11383 arg1 = (int)(SWIG_As_int(obj0));
11384 if (SWIG_arg_fail(1)) SWIG_fail;
11385 }
11386 }
11387 {
11388 if (!wxPyCheckForApp()) SWIG_fail;
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 result = (wxJoystick *)new wxJoystick(arg1);
11391
11392 wxPyEndAllowThreads(__tstate);
11393 if (PyErr_Occurred()) SWIG_fail;
11394 }
11395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11396 return resultobj;
11397 fail:
11398 return NULL;
11399 }
11400
11401
11402 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11403 PyObject *resultobj;
11404 wxJoystick *arg1 = (wxJoystick *) 0 ;
11405 PyObject * obj0 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "self", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11412 if (SWIG_arg_fail(1)) SWIG_fail;
11413 {
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 delete arg1;
11416
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 Py_INCREF(Py_None); resultobj = Py_None;
11421 return resultobj;
11422 fail:
11423 return NULL;
11424 }
11425
11426
11427 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11428 PyObject *resultobj;
11429 wxJoystick *arg1 = (wxJoystick *) 0 ;
11430 wxPoint result;
11431 PyObject * obj0 = 0 ;
11432 char *kwnames[] = {
11433 (char *) "self", NULL
11434 };
11435
11436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11438 if (SWIG_arg_fail(1)) SWIG_fail;
11439 {
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 result = (arg1)->GetPosition();
11442
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 {
11447 wxPoint * resultptr;
11448 resultptr = new wxPoint((wxPoint &)(result));
11449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11450 }
11451 return resultobj;
11452 fail:
11453 return NULL;
11454 }
11455
11456
11457 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11458 PyObject *resultobj;
11459 wxJoystick *arg1 = (wxJoystick *) 0 ;
11460 int result;
11461 PyObject * obj0 = 0 ;
11462 char *kwnames[] = {
11463 (char *) "self", NULL
11464 };
11465
11466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11468 if (SWIG_arg_fail(1)) SWIG_fail;
11469 {
11470 PyThreadState* __tstate = wxPyBeginAllowThreads();
11471 result = (int)(arg1)->GetZPosition();
11472
11473 wxPyEndAllowThreads(__tstate);
11474 if (PyErr_Occurred()) SWIG_fail;
11475 }
11476 {
11477 resultobj = SWIG_From_int((int)(result));
11478 }
11479 return resultobj;
11480 fail:
11481 return NULL;
11482 }
11483
11484
11485 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11486 PyObject *resultobj;
11487 wxJoystick *arg1 = (wxJoystick *) 0 ;
11488 int result;
11489 PyObject * obj0 = 0 ;
11490 char *kwnames[] = {
11491 (char *) "self", NULL
11492 };
11493
11494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11496 if (SWIG_arg_fail(1)) SWIG_fail;
11497 {
11498 PyThreadState* __tstate = wxPyBeginAllowThreads();
11499 result = (int)(arg1)->GetButtonState();
11500
11501 wxPyEndAllowThreads(__tstate);
11502 if (PyErr_Occurred()) SWIG_fail;
11503 }
11504 {
11505 resultobj = SWIG_From_int((int)(result));
11506 }
11507 return resultobj;
11508 fail:
11509 return NULL;
11510 }
11511
11512
11513 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11514 PyObject *resultobj;
11515 wxJoystick *arg1 = (wxJoystick *) 0 ;
11516 int result;
11517 PyObject * obj0 = 0 ;
11518 char *kwnames[] = {
11519 (char *) "self", NULL
11520 };
11521
11522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11524 if (SWIG_arg_fail(1)) SWIG_fail;
11525 {
11526 PyThreadState* __tstate = wxPyBeginAllowThreads();
11527 result = (int)(arg1)->GetPOVPosition();
11528
11529 wxPyEndAllowThreads(__tstate);
11530 if (PyErr_Occurred()) SWIG_fail;
11531 }
11532 {
11533 resultobj = SWIG_From_int((int)(result));
11534 }
11535 return resultobj;
11536 fail:
11537 return NULL;
11538 }
11539
11540
11541 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11542 PyObject *resultobj;
11543 wxJoystick *arg1 = (wxJoystick *) 0 ;
11544 int result;
11545 PyObject * obj0 = 0 ;
11546 char *kwnames[] = {
11547 (char *) "self", NULL
11548 };
11549
11550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11552 if (SWIG_arg_fail(1)) SWIG_fail;
11553 {
11554 PyThreadState* __tstate = wxPyBeginAllowThreads();
11555 result = (int)(arg1)->GetPOVCTSPosition();
11556
11557 wxPyEndAllowThreads(__tstate);
11558 if (PyErr_Occurred()) SWIG_fail;
11559 }
11560 {
11561 resultobj = SWIG_From_int((int)(result));
11562 }
11563 return resultobj;
11564 fail:
11565 return NULL;
11566 }
11567
11568
11569 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11570 PyObject *resultobj;
11571 wxJoystick *arg1 = (wxJoystick *) 0 ;
11572 int result;
11573 PyObject * obj0 = 0 ;
11574 char *kwnames[] = {
11575 (char *) "self", NULL
11576 };
11577
11578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11580 if (SWIG_arg_fail(1)) SWIG_fail;
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 result = (int)(arg1)->GetRudderPosition();
11584
11585 wxPyEndAllowThreads(__tstate);
11586 if (PyErr_Occurred()) SWIG_fail;
11587 }
11588 {
11589 resultobj = SWIG_From_int((int)(result));
11590 }
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11598 PyObject *resultobj;
11599 wxJoystick *arg1 = (wxJoystick *) 0 ;
11600 int result;
11601 PyObject * obj0 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "self", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (int)(arg1)->GetUPosition();
11612
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 resultobj = SWIG_From_int((int)(result));
11618 }
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj;
11627 wxJoystick *arg1 = (wxJoystick *) 0 ;
11628 int result;
11629 PyObject * obj0 = 0 ;
11630 char *kwnames[] = {
11631 (char *) "self", NULL
11632 };
11633
11634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11636 if (SWIG_arg_fail(1)) SWIG_fail;
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (int)(arg1)->GetVPosition();
11640
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 {
11645 resultobj = SWIG_From_int((int)(result));
11646 }
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11654 PyObject *resultobj;
11655 wxJoystick *arg1 = (wxJoystick *) 0 ;
11656 int result;
11657 PyObject * obj0 = 0 ;
11658 char *kwnames[] = {
11659 (char *) "self", NULL
11660 };
11661
11662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11664 if (SWIG_arg_fail(1)) SWIG_fail;
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (int)(arg1)->GetMovementThreshold();
11668
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = SWIG_From_int((int)(result));
11674 }
11675 return resultobj;
11676 fail:
11677 return NULL;
11678 }
11679
11680
11681 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj;
11683 wxJoystick *arg1 = (wxJoystick *) 0 ;
11684 int arg2 ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 char *kwnames[] = {
11688 (char *) "self",(char *) "threshold", NULL
11689 };
11690
11691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11693 if (SWIG_arg_fail(1)) SWIG_fail;
11694 {
11695 arg2 = (int)(SWIG_As_int(obj1));
11696 if (SWIG_arg_fail(2)) SWIG_fail;
11697 }
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 (arg1)->SetMovementThreshold(arg2);
11701
11702 wxPyEndAllowThreads(__tstate);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 Py_INCREF(Py_None); resultobj = Py_None;
11706 return resultobj;
11707 fail:
11708 return NULL;
11709 }
11710
11711
11712 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11713 PyObject *resultobj;
11714 wxJoystick *arg1 = (wxJoystick *) 0 ;
11715 bool result;
11716 PyObject * obj0 = 0 ;
11717 char *kwnames[] = {
11718 (char *) "self", NULL
11719 };
11720
11721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11723 if (SWIG_arg_fail(1)) SWIG_fail;
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (bool)(arg1)->IsOk();
11727
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11733 }
11734 return resultobj;
11735 fail:
11736 return NULL;
11737 }
11738
11739
11740 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11741 PyObject *resultobj;
11742 wxJoystick *arg1 = (wxJoystick *) 0 ;
11743 int result;
11744 PyObject * obj0 = 0 ;
11745 char *kwnames[] = {
11746 (char *) "self", NULL
11747 };
11748
11749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11751 if (SWIG_arg_fail(1)) SWIG_fail;
11752 {
11753 PyThreadState* __tstate = wxPyBeginAllowThreads();
11754 result = (int)(arg1)->GetNumberJoysticks();
11755
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 {
11760 resultobj = SWIG_From_int((int)(result));
11761 }
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11769 PyObject *resultobj;
11770 wxJoystick *arg1 = (wxJoystick *) 0 ;
11771 int result;
11772 PyObject * obj0 = 0 ;
11773 char *kwnames[] = {
11774 (char *) "self", NULL
11775 };
11776
11777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11779 if (SWIG_arg_fail(1)) SWIG_fail;
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (int)(arg1)->GetManufacturerId();
11783
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 {
11788 resultobj = SWIG_From_int((int)(result));
11789 }
11790 return resultobj;
11791 fail:
11792 return NULL;
11793 }
11794
11795
11796 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj;
11798 wxJoystick *arg1 = (wxJoystick *) 0 ;
11799 int result;
11800 PyObject * obj0 = 0 ;
11801 char *kwnames[] = {
11802 (char *) "self", NULL
11803 };
11804
11805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11807 if (SWIG_arg_fail(1)) SWIG_fail;
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (int)(arg1)->GetProductId();
11811
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 {
11816 resultobj = SWIG_From_int((int)(result));
11817 }
11818 return resultobj;
11819 fail:
11820 return NULL;
11821 }
11822
11823
11824 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11825 PyObject *resultobj;
11826 wxJoystick *arg1 = (wxJoystick *) 0 ;
11827 wxString result;
11828 PyObject * obj0 = 0 ;
11829 char *kwnames[] = {
11830 (char *) "self", NULL
11831 };
11832
11833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11835 if (SWIG_arg_fail(1)) SWIG_fail;
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (arg1)->GetProductName();
11839
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 {
11844 #if wxUSE_UNICODE
11845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11846 #else
11847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11848 #endif
11849 }
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11857 PyObject *resultobj;
11858 wxJoystick *arg1 = (wxJoystick *) 0 ;
11859 int result;
11860 PyObject * obj0 = 0 ;
11861 char *kwnames[] = {
11862 (char *) "self", NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11867 if (SWIG_arg_fail(1)) SWIG_fail;
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 result = (int)(arg1)->GetXMin();
11871
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 resultobj = SWIG_From_int((int)(result));
11877 }
11878 return resultobj;
11879 fail:
11880 return NULL;
11881 }
11882
11883
11884 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11885 PyObject *resultobj;
11886 wxJoystick *arg1 = (wxJoystick *) 0 ;
11887 int result;
11888 PyObject * obj0 = 0 ;
11889 char *kwnames[] = {
11890 (char *) "self", NULL
11891 };
11892
11893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11895 if (SWIG_arg_fail(1)) SWIG_fail;
11896 {
11897 PyThreadState* __tstate = wxPyBeginAllowThreads();
11898 result = (int)(arg1)->GetYMin();
11899
11900 wxPyEndAllowThreads(__tstate);
11901 if (PyErr_Occurred()) SWIG_fail;
11902 }
11903 {
11904 resultobj = SWIG_From_int((int)(result));
11905 }
11906 return resultobj;
11907 fail:
11908 return NULL;
11909 }
11910
11911
11912 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11913 PyObject *resultobj;
11914 wxJoystick *arg1 = (wxJoystick *) 0 ;
11915 int result;
11916 PyObject * obj0 = 0 ;
11917 char *kwnames[] = {
11918 (char *) "self", NULL
11919 };
11920
11921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11923 if (SWIG_arg_fail(1)) SWIG_fail;
11924 {
11925 PyThreadState* __tstate = wxPyBeginAllowThreads();
11926 result = (int)(arg1)->GetZMin();
11927
11928 wxPyEndAllowThreads(__tstate);
11929 if (PyErr_Occurred()) SWIG_fail;
11930 }
11931 {
11932 resultobj = SWIG_From_int((int)(result));
11933 }
11934 return resultobj;
11935 fail:
11936 return NULL;
11937 }
11938
11939
11940 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11941 PyObject *resultobj;
11942 wxJoystick *arg1 = (wxJoystick *) 0 ;
11943 int result;
11944 PyObject * obj0 = 0 ;
11945 char *kwnames[] = {
11946 (char *) "self", NULL
11947 };
11948
11949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11951 if (SWIG_arg_fail(1)) SWIG_fail;
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (int)(arg1)->GetXMax();
11955
11956 wxPyEndAllowThreads(__tstate);
11957 if (PyErr_Occurred()) SWIG_fail;
11958 }
11959 {
11960 resultobj = SWIG_From_int((int)(result));
11961 }
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11969 PyObject *resultobj;
11970 wxJoystick *arg1 = (wxJoystick *) 0 ;
11971 int result;
11972 PyObject * obj0 = 0 ;
11973 char *kwnames[] = {
11974 (char *) "self", NULL
11975 };
11976
11977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11979 if (SWIG_arg_fail(1)) SWIG_fail;
11980 {
11981 PyThreadState* __tstate = wxPyBeginAllowThreads();
11982 result = (int)(arg1)->GetYMax();
11983
11984 wxPyEndAllowThreads(__tstate);
11985 if (PyErr_Occurred()) SWIG_fail;
11986 }
11987 {
11988 resultobj = SWIG_From_int((int)(result));
11989 }
11990 return resultobj;
11991 fail:
11992 return NULL;
11993 }
11994
11995
11996 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
11997 PyObject *resultobj;
11998 wxJoystick *arg1 = (wxJoystick *) 0 ;
11999 int result;
12000 PyObject * obj0 = 0 ;
12001 char *kwnames[] = {
12002 (char *) "self", NULL
12003 };
12004
12005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12007 if (SWIG_arg_fail(1)) SWIG_fail;
12008 {
12009 PyThreadState* __tstate = wxPyBeginAllowThreads();
12010 result = (int)(arg1)->GetZMax();
12011
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = SWIG_From_int((int)(result));
12017 }
12018 return resultobj;
12019 fail:
12020 return NULL;
12021 }
12022
12023
12024 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj;
12026 wxJoystick *arg1 = (wxJoystick *) 0 ;
12027 int result;
12028 PyObject * obj0 = 0 ;
12029 char *kwnames[] = {
12030 (char *) "self", NULL
12031 };
12032
12033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12035 if (SWIG_arg_fail(1)) SWIG_fail;
12036 {
12037 PyThreadState* __tstate = wxPyBeginAllowThreads();
12038 result = (int)(arg1)->GetNumberButtons();
12039
12040 wxPyEndAllowThreads(__tstate);
12041 if (PyErr_Occurred()) SWIG_fail;
12042 }
12043 {
12044 resultobj = SWIG_From_int((int)(result));
12045 }
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj;
12054 wxJoystick *arg1 = (wxJoystick *) 0 ;
12055 int result;
12056 PyObject * obj0 = 0 ;
12057 char *kwnames[] = {
12058 (char *) "self", NULL
12059 };
12060
12061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12063 if (SWIG_arg_fail(1)) SWIG_fail;
12064 {
12065 PyThreadState* __tstate = wxPyBeginAllowThreads();
12066 result = (int)(arg1)->GetNumberAxes();
12067
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 {
12072 resultobj = SWIG_From_int((int)(result));
12073 }
12074 return resultobj;
12075 fail:
12076 return NULL;
12077 }
12078
12079
12080 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12081 PyObject *resultobj;
12082 wxJoystick *arg1 = (wxJoystick *) 0 ;
12083 int result;
12084 PyObject * obj0 = 0 ;
12085 char *kwnames[] = {
12086 (char *) "self", NULL
12087 };
12088
12089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12091 if (SWIG_arg_fail(1)) SWIG_fail;
12092 {
12093 PyThreadState* __tstate = wxPyBeginAllowThreads();
12094 result = (int)(arg1)->GetMaxButtons();
12095
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 {
12100 resultobj = SWIG_From_int((int)(result));
12101 }
12102 return resultobj;
12103 fail:
12104 return NULL;
12105 }
12106
12107
12108 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12109 PyObject *resultobj;
12110 wxJoystick *arg1 = (wxJoystick *) 0 ;
12111 int result;
12112 PyObject * obj0 = 0 ;
12113 char *kwnames[] = {
12114 (char *) "self", NULL
12115 };
12116
12117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12119 if (SWIG_arg_fail(1)) SWIG_fail;
12120 {
12121 PyThreadState* __tstate = wxPyBeginAllowThreads();
12122 result = (int)(arg1)->GetMaxAxes();
12123
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 resultobj = SWIG_From_int((int)(result));
12129 }
12130 return resultobj;
12131 fail:
12132 return NULL;
12133 }
12134
12135
12136 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12137 PyObject *resultobj;
12138 wxJoystick *arg1 = (wxJoystick *) 0 ;
12139 int result;
12140 PyObject * obj0 = 0 ;
12141 char *kwnames[] = {
12142 (char *) "self", NULL
12143 };
12144
12145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12147 if (SWIG_arg_fail(1)) SWIG_fail;
12148 {
12149 PyThreadState* __tstate = wxPyBeginAllowThreads();
12150 result = (int)(arg1)->GetPollingMin();
12151
12152 wxPyEndAllowThreads(__tstate);
12153 if (PyErr_Occurred()) SWIG_fail;
12154 }
12155 {
12156 resultobj = SWIG_From_int((int)(result));
12157 }
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12165 PyObject *resultobj;
12166 wxJoystick *arg1 = (wxJoystick *) 0 ;
12167 int result;
12168 PyObject * obj0 = 0 ;
12169 char *kwnames[] = {
12170 (char *) "self", NULL
12171 };
12172
12173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12175 if (SWIG_arg_fail(1)) SWIG_fail;
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = (int)(arg1)->GetPollingMax();
12179
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 {
12184 resultobj = SWIG_From_int((int)(result));
12185 }
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12193 PyObject *resultobj;
12194 wxJoystick *arg1 = (wxJoystick *) 0 ;
12195 int result;
12196 PyObject * obj0 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "self", NULL
12199 };
12200
12201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12203 if (SWIG_arg_fail(1)) SWIG_fail;
12204 {
12205 PyThreadState* __tstate = wxPyBeginAllowThreads();
12206 result = (int)(arg1)->GetRudderMin();
12207
12208 wxPyEndAllowThreads(__tstate);
12209 if (PyErr_Occurred()) SWIG_fail;
12210 }
12211 {
12212 resultobj = SWIG_From_int((int)(result));
12213 }
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12221 PyObject *resultobj;
12222 wxJoystick *arg1 = (wxJoystick *) 0 ;
12223 int result;
12224 PyObject * obj0 = 0 ;
12225 char *kwnames[] = {
12226 (char *) "self", NULL
12227 };
12228
12229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12231 if (SWIG_arg_fail(1)) SWIG_fail;
12232 {
12233 PyThreadState* __tstate = wxPyBeginAllowThreads();
12234 result = (int)(arg1)->GetRudderMax();
12235
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 {
12240 resultobj = SWIG_From_int((int)(result));
12241 }
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12249 PyObject *resultobj;
12250 wxJoystick *arg1 = (wxJoystick *) 0 ;
12251 int result;
12252 PyObject * obj0 = 0 ;
12253 char *kwnames[] = {
12254 (char *) "self", NULL
12255 };
12256
12257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12259 if (SWIG_arg_fail(1)) SWIG_fail;
12260 {
12261 PyThreadState* __tstate = wxPyBeginAllowThreads();
12262 result = (int)(arg1)->GetUMin();
12263
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 {
12268 resultobj = SWIG_From_int((int)(result));
12269 }
12270 return resultobj;
12271 fail:
12272 return NULL;
12273 }
12274
12275
12276 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12277 PyObject *resultobj;
12278 wxJoystick *arg1 = (wxJoystick *) 0 ;
12279 int result;
12280 PyObject * obj0 = 0 ;
12281 char *kwnames[] = {
12282 (char *) "self", NULL
12283 };
12284
12285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12287 if (SWIG_arg_fail(1)) SWIG_fail;
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 result = (int)(arg1)->GetUMax();
12291
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 {
12296 resultobj = SWIG_From_int((int)(result));
12297 }
12298 return resultobj;
12299 fail:
12300 return NULL;
12301 }
12302
12303
12304 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12305 PyObject *resultobj;
12306 wxJoystick *arg1 = (wxJoystick *) 0 ;
12307 int result;
12308 PyObject * obj0 = 0 ;
12309 char *kwnames[] = {
12310 (char *) "self", NULL
12311 };
12312
12313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12315 if (SWIG_arg_fail(1)) SWIG_fail;
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 result = (int)(arg1)->GetVMin();
12319
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 {
12324 resultobj = SWIG_From_int((int)(result));
12325 }
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12333 PyObject *resultobj;
12334 wxJoystick *arg1 = (wxJoystick *) 0 ;
12335 int result;
12336 PyObject * obj0 = 0 ;
12337 char *kwnames[] = {
12338 (char *) "self", NULL
12339 };
12340
12341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12343 if (SWIG_arg_fail(1)) SWIG_fail;
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 result = (int)(arg1)->GetVMax();
12347
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 {
12352 resultobj = SWIG_From_int((int)(result));
12353 }
12354 return resultobj;
12355 fail:
12356 return NULL;
12357 }
12358
12359
12360 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12361 PyObject *resultobj;
12362 wxJoystick *arg1 = (wxJoystick *) 0 ;
12363 bool result;
12364 PyObject * obj0 = 0 ;
12365 char *kwnames[] = {
12366 (char *) "self", NULL
12367 };
12368
12369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12371 if (SWIG_arg_fail(1)) SWIG_fail;
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 result = (bool)(arg1)->HasRudder();
12375
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 {
12380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12381 }
12382 return resultobj;
12383 fail:
12384 return NULL;
12385 }
12386
12387
12388 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12389 PyObject *resultobj;
12390 wxJoystick *arg1 = (wxJoystick *) 0 ;
12391 bool result;
12392 PyObject * obj0 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (bool)(arg1)->HasZ();
12403
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12409 }
12410 return resultobj;
12411 fail:
12412 return NULL;
12413 }
12414
12415
12416 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12417 PyObject *resultobj;
12418 wxJoystick *arg1 = (wxJoystick *) 0 ;
12419 bool result;
12420 PyObject * obj0 = 0 ;
12421 char *kwnames[] = {
12422 (char *) "self", NULL
12423 };
12424
12425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12427 if (SWIG_arg_fail(1)) SWIG_fail;
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 result = (bool)(arg1)->HasU();
12431
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 {
12436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12437 }
12438 return resultobj;
12439 fail:
12440 return NULL;
12441 }
12442
12443
12444 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12445 PyObject *resultobj;
12446 wxJoystick *arg1 = (wxJoystick *) 0 ;
12447 bool result;
12448 PyObject * obj0 = 0 ;
12449 char *kwnames[] = {
12450 (char *) "self", NULL
12451 };
12452
12453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12455 if (SWIG_arg_fail(1)) SWIG_fail;
12456 {
12457 PyThreadState* __tstate = wxPyBeginAllowThreads();
12458 result = (bool)(arg1)->HasV();
12459
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12465 }
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj;
12474 wxJoystick *arg1 = (wxJoystick *) 0 ;
12475 bool result;
12476 PyObject * obj0 = 0 ;
12477 char *kwnames[] = {
12478 (char *) "self", NULL
12479 };
12480
12481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12483 if (SWIG_arg_fail(1)) SWIG_fail;
12484 {
12485 PyThreadState* __tstate = wxPyBeginAllowThreads();
12486 result = (bool)(arg1)->HasPOV();
12487
12488 wxPyEndAllowThreads(__tstate);
12489 if (PyErr_Occurred()) SWIG_fail;
12490 }
12491 {
12492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12493 }
12494 return resultobj;
12495 fail:
12496 return NULL;
12497 }
12498
12499
12500 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12501 PyObject *resultobj;
12502 wxJoystick *arg1 = (wxJoystick *) 0 ;
12503 bool result;
12504 PyObject * obj0 = 0 ;
12505 char *kwnames[] = {
12506 (char *) "self", NULL
12507 };
12508
12509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12511 if (SWIG_arg_fail(1)) SWIG_fail;
12512 {
12513 PyThreadState* __tstate = wxPyBeginAllowThreads();
12514 result = (bool)(arg1)->HasPOV4Dir();
12515
12516 wxPyEndAllowThreads(__tstate);
12517 if (PyErr_Occurred()) SWIG_fail;
12518 }
12519 {
12520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12521 }
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj;
12530 wxJoystick *arg1 = (wxJoystick *) 0 ;
12531 bool result;
12532 PyObject * obj0 = 0 ;
12533 char *kwnames[] = {
12534 (char *) "self", NULL
12535 };
12536
12537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12539 if (SWIG_arg_fail(1)) SWIG_fail;
12540 {
12541 PyThreadState* __tstate = wxPyBeginAllowThreads();
12542 result = (bool)(arg1)->HasPOVCTS();
12543
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 {
12548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12549 }
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj;
12558 wxJoystick *arg1 = (wxJoystick *) 0 ;
12559 wxWindow *arg2 = (wxWindow *) 0 ;
12560 int arg3 = (int) 0 ;
12561 bool result;
12562 PyObject * obj0 = 0 ;
12563 PyObject * obj1 = 0 ;
12564 PyObject * obj2 = 0 ;
12565 char *kwnames[] = {
12566 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12567 };
12568
12569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12571 if (SWIG_arg_fail(1)) SWIG_fail;
12572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12573 if (SWIG_arg_fail(2)) SWIG_fail;
12574 if (obj2) {
12575 {
12576 arg3 = (int)(SWIG_As_int(obj2));
12577 if (SWIG_arg_fail(3)) SWIG_fail;
12578 }
12579 }
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (bool)(arg1)->SetCapture(arg2,arg3);
12583
12584 wxPyEndAllowThreads(__tstate);
12585 if (PyErr_Occurred()) SWIG_fail;
12586 }
12587 {
12588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12589 }
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj;
12598 wxJoystick *arg1 = (wxJoystick *) 0 ;
12599 bool result;
12600 PyObject * obj0 = 0 ;
12601 char *kwnames[] = {
12602 (char *) "self", NULL
12603 };
12604
12605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12607 if (SWIG_arg_fail(1)) SWIG_fail;
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = (bool)(arg1)->ReleaseCapture();
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 {
12616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12617 }
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12625 PyObject *obj;
12626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12627 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12628 Py_INCREF(obj);
12629 return Py_BuildValue((char *)"");
12630 }
12631 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj;
12633 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12634 int arg2 = (int) 0 ;
12635 int arg3 = (int) wxJOYSTICK1 ;
12636 int arg4 = (int) 0 ;
12637 wxJoystickEvent *result;
12638 PyObject * obj0 = 0 ;
12639 PyObject * obj1 = 0 ;
12640 PyObject * obj2 = 0 ;
12641 PyObject * obj3 = 0 ;
12642 char *kwnames[] = {
12643 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12644 };
12645
12646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12647 if (obj0) {
12648 {
12649 arg1 = (wxEventType)(SWIG_As_int(obj0));
12650 if (SWIG_arg_fail(1)) SWIG_fail;
12651 }
12652 }
12653 if (obj1) {
12654 {
12655 arg2 = (int)(SWIG_As_int(obj1));
12656 if (SWIG_arg_fail(2)) SWIG_fail;
12657 }
12658 }
12659 if (obj2) {
12660 {
12661 arg3 = (int)(SWIG_As_int(obj2));
12662 if (SWIG_arg_fail(3)) SWIG_fail;
12663 }
12664 }
12665 if (obj3) {
12666 {
12667 arg4 = (int)(SWIG_As_int(obj3));
12668 if (SWIG_arg_fail(4)) SWIG_fail;
12669 }
12670 }
12671 {
12672 PyThreadState* __tstate = wxPyBeginAllowThreads();
12673 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12674
12675 wxPyEndAllowThreads(__tstate);
12676 if (PyErr_Occurred()) SWIG_fail;
12677 }
12678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12679 return resultobj;
12680 fail:
12681 return NULL;
12682 }
12683
12684
12685 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12686 PyObject *resultobj;
12687 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12688 wxPoint result;
12689 PyObject * obj0 = 0 ;
12690 char *kwnames[] = {
12691 (char *) "self", NULL
12692 };
12693
12694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12696 if (SWIG_arg_fail(1)) SWIG_fail;
12697 {
12698 PyThreadState* __tstate = wxPyBeginAllowThreads();
12699 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12700
12701 wxPyEndAllowThreads(__tstate);
12702 if (PyErr_Occurred()) SWIG_fail;
12703 }
12704 {
12705 wxPoint * resultptr;
12706 resultptr = new wxPoint((wxPoint &)(result));
12707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12708 }
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj;
12717 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12718 int result;
12719 PyObject * obj0 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12730
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 {
12735 resultobj = SWIG_From_int((int)(result));
12736 }
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj;
12745 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12746 int result;
12747 PyObject * obj0 = 0 ;
12748 char *kwnames[] = {
12749 (char *) "self", NULL
12750 };
12751
12752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12754 if (SWIG_arg_fail(1)) SWIG_fail;
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12758
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 {
12763 resultobj = SWIG_From_int((int)(result));
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12772 PyObject *resultobj;
12773 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12774 int result;
12775 PyObject * obj0 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12786
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 {
12791 resultobj = SWIG_From_int((int)(result));
12792 }
12793 return resultobj;
12794 fail:
12795 return NULL;
12796 }
12797
12798
12799 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12800 PyObject *resultobj;
12801 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12802 int result;
12803 PyObject * obj0 = 0 ;
12804 char *kwnames[] = {
12805 (char *) "self", NULL
12806 };
12807
12808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12810 if (SWIG_arg_fail(1)) SWIG_fail;
12811 {
12812 PyThreadState* __tstate = wxPyBeginAllowThreads();
12813 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12814
12815 wxPyEndAllowThreads(__tstate);
12816 if (PyErr_Occurred()) SWIG_fail;
12817 }
12818 {
12819 resultobj = SWIG_From_int((int)(result));
12820 }
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj;
12829 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12830 int arg2 ;
12831 PyObject * obj0 = 0 ;
12832 PyObject * obj1 = 0 ;
12833 char *kwnames[] = {
12834 (char *) "self",(char *) "stick", NULL
12835 };
12836
12837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12839 if (SWIG_arg_fail(1)) SWIG_fail;
12840 {
12841 arg2 = (int)(SWIG_As_int(obj1));
12842 if (SWIG_arg_fail(2)) SWIG_fail;
12843 }
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 (arg1)->SetJoystick(arg2);
12847
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 Py_INCREF(Py_None); resultobj = Py_None;
12852 return resultobj;
12853 fail:
12854 return NULL;
12855 }
12856
12857
12858 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj;
12860 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12861 int arg2 ;
12862 PyObject * obj0 = 0 ;
12863 PyObject * obj1 = 0 ;
12864 char *kwnames[] = {
12865 (char *) "self",(char *) "state", NULL
12866 };
12867
12868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12870 if (SWIG_arg_fail(1)) SWIG_fail;
12871 {
12872 arg2 = (int)(SWIG_As_int(obj1));
12873 if (SWIG_arg_fail(2)) SWIG_fail;
12874 }
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 (arg1)->SetButtonState(arg2);
12878
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 Py_INCREF(Py_None); resultobj = Py_None;
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12890 PyObject *resultobj;
12891 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12892 int arg2 ;
12893 PyObject * obj0 = 0 ;
12894 PyObject * obj1 = 0 ;
12895 char *kwnames[] = {
12896 (char *) "self",(char *) "change", NULL
12897 };
12898
12899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12901 if (SWIG_arg_fail(1)) SWIG_fail;
12902 {
12903 arg2 = (int)(SWIG_As_int(obj1));
12904 if (SWIG_arg_fail(2)) SWIG_fail;
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 (arg1)->SetButtonChange(arg2);
12909
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 Py_INCREF(Py_None); resultobj = Py_None;
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj;
12922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12923 wxPoint *arg2 = 0 ;
12924 wxPoint temp2 ;
12925 PyObject * obj0 = 0 ;
12926 PyObject * obj1 = 0 ;
12927 char *kwnames[] = {
12928 (char *) "self",(char *) "pos", NULL
12929 };
12930
12931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12933 if (SWIG_arg_fail(1)) SWIG_fail;
12934 {
12935 arg2 = &temp2;
12936 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12937 }
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 (arg1)->SetPosition((wxPoint const &)*arg2);
12941
12942 wxPyEndAllowThreads(__tstate);
12943 if (PyErr_Occurred()) SWIG_fail;
12944 }
12945 Py_INCREF(Py_None); resultobj = Py_None;
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12953 PyObject *resultobj;
12954 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12955 int arg2 ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 char *kwnames[] = {
12959 (char *) "self",(char *) "zPos", NULL
12960 };
12961
12962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12964 if (SWIG_arg_fail(1)) SWIG_fail;
12965 {
12966 arg2 = (int)(SWIG_As_int(obj1));
12967 if (SWIG_arg_fail(2)) SWIG_fail;
12968 }
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 (arg1)->SetZPosition(arg2);
12972
12973 wxPyEndAllowThreads(__tstate);
12974 if (PyErr_Occurred()) SWIG_fail;
12975 }
12976 Py_INCREF(Py_None); resultobj = Py_None;
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12986 bool result;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 {
13003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13004 }
13005 return resultobj;
13006 fail:
13007 return NULL;
13008 }
13009
13010
13011 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13012 PyObject *resultobj;
13013 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13014 bool result;
13015 PyObject * obj0 = 0 ;
13016 char *kwnames[] = {
13017 (char *) "self", NULL
13018 };
13019
13020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13022 if (SWIG_arg_fail(1)) SWIG_fail;
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13026
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 {
13031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13032 }
13033 return resultobj;
13034 fail:
13035 return NULL;
13036 }
13037
13038
13039 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13040 PyObject *resultobj;
13041 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13042 bool result;
13043 PyObject * obj0 = 0 ;
13044 char *kwnames[] = {
13045 (char *) "self", NULL
13046 };
13047
13048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13050 if (SWIG_arg_fail(1)) SWIG_fail;
13051 {
13052 PyThreadState* __tstate = wxPyBeginAllowThreads();
13053 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13054
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 {
13059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13060 }
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13070 int arg2 = (int) wxJOY_BUTTON_ANY ;
13071 bool result;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "but", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 if (obj1) {
13082 {
13083 arg2 = (int)(SWIG_As_int(obj1));
13084 if (SWIG_arg_fail(2)) SWIG_fail;
13085 }
13086 }
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 {
13095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13096 }
13097 return resultobj;
13098 fail:
13099 return NULL;
13100 }
13101
13102
13103 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj;
13105 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13106 int arg2 = (int) wxJOY_BUTTON_ANY ;
13107 bool result;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 char *kwnames[] = {
13111 (char *) "self",(char *) "but", NULL
13112 };
13113
13114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13116 if (SWIG_arg_fail(1)) SWIG_fail;
13117 if (obj1) {
13118 {
13119 arg2 = (int)(SWIG_As_int(obj1));
13120 if (SWIG_arg_fail(2)) SWIG_fail;
13121 }
13122 }
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13142 int arg2 = (int) wxJOY_BUTTON_ANY ;
13143 bool result;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 char *kwnames[] = {
13147 (char *) "self",(char *) "but", NULL
13148 };
13149
13150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(1)) SWIG_fail;
13153 if (obj1) {
13154 {
13155 arg2 = (int)(SWIG_As_int(obj1));
13156 if (SWIG_arg_fail(2)) SWIG_fail;
13157 }
13158 }
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 {
13167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13168 }
13169 return resultobj;
13170 fail:
13171 return NULL;
13172 }
13173
13174
13175 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13176 PyObject *obj;
13177 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13178 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13179 Py_INCREF(obj);
13180 return Py_BuildValue((char *)"");
13181 }
13182 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj;
13184 wxString const &arg1_defvalue = wxPyEmptyString ;
13185 wxString *arg1 = (wxString *) &arg1_defvalue ;
13186 wxSound *result;
13187 bool temp1 = false ;
13188 PyObject * obj0 = 0 ;
13189 char *kwnames[] = {
13190 (char *) "fileName", NULL
13191 };
13192
13193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13194 if (obj0) {
13195 {
13196 arg1 = wxString_in_helper(obj0);
13197 if (arg1 == NULL) SWIG_fail;
13198 temp1 = true;
13199 }
13200 }
13201 {
13202 if (!wxPyCheckForApp()) SWIG_fail;
13203 PyThreadState* __tstate = wxPyBeginAllowThreads();
13204 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13205
13206 wxPyEndAllowThreads(__tstate);
13207 if (PyErr_Occurred()) SWIG_fail;
13208 }
13209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13210 {
13211 if (temp1)
13212 delete arg1;
13213 }
13214 return resultobj;
13215 fail:
13216 {
13217 if (temp1)
13218 delete arg1;
13219 }
13220 return NULL;
13221 }
13222
13223
13224 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13225 PyObject *resultobj;
13226 PyObject *arg1 = (PyObject *) 0 ;
13227 wxSound *result;
13228 PyObject * obj0 = 0 ;
13229 char *kwnames[] = {
13230 (char *) "data", NULL
13231 };
13232
13233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13234 arg1 = obj0;
13235 {
13236 if (!wxPyCheckForApp()) SWIG_fail;
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 result = (wxSound *)new_wxSound(arg1);
13239
13240 wxPyEndAllowThreads(__tstate);
13241 if (PyErr_Occurred()) SWIG_fail;
13242 }
13243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxSound *arg1 = (wxSound *) 0 ;
13253 PyObject * obj0 = 0 ;
13254 char *kwnames[] = {
13255 (char *) "self", NULL
13256 };
13257
13258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13260 if (SWIG_arg_fail(1)) SWIG_fail;
13261 {
13262 PyThreadState* __tstate = wxPyBeginAllowThreads();
13263 delete arg1;
13264
13265 wxPyEndAllowThreads(__tstate);
13266 if (PyErr_Occurred()) SWIG_fail;
13267 }
13268 Py_INCREF(Py_None); resultobj = Py_None;
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj;
13277 wxSound *arg1 = (wxSound *) 0 ;
13278 wxString *arg2 = 0 ;
13279 bool result;
13280 bool temp2 = false ;
13281 PyObject * obj0 = 0 ;
13282 PyObject * obj1 = 0 ;
13283 char *kwnames[] = {
13284 (char *) "self",(char *) "fileName", NULL
13285 };
13286
13287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13289 if (SWIG_arg_fail(1)) SWIG_fail;
13290 {
13291 arg2 = wxString_in_helper(obj1);
13292 if (arg2 == NULL) SWIG_fail;
13293 temp2 = true;
13294 }
13295 {
13296 PyThreadState* __tstate = wxPyBeginAllowThreads();
13297 result = (bool)(arg1)->Create((wxString const &)*arg2);
13298
13299 wxPyEndAllowThreads(__tstate);
13300 if (PyErr_Occurred()) SWIG_fail;
13301 }
13302 {
13303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13304 }
13305 {
13306 if (temp2)
13307 delete arg2;
13308 }
13309 return resultobj;
13310 fail:
13311 {
13312 if (temp2)
13313 delete arg2;
13314 }
13315 return NULL;
13316 }
13317
13318
13319 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj;
13321 wxSound *arg1 = (wxSound *) 0 ;
13322 PyObject *arg2 = (PyObject *) 0 ;
13323 bool result;
13324 PyObject * obj0 = 0 ;
13325 PyObject * obj1 = 0 ;
13326 char *kwnames[] = {
13327 (char *) "self",(char *) "data", NULL
13328 };
13329
13330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13332 if (SWIG_arg_fail(1)) SWIG_fail;
13333 arg2 = obj1;
13334 {
13335 PyThreadState* __tstate = wxPyBeginAllowThreads();
13336 result = (bool)wxSound_CreateFromData(arg1,arg2);
13337
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 {
13342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13343 }
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13351 PyObject *resultobj;
13352 wxSound *arg1 = (wxSound *) 0 ;
13353 bool result;
13354 PyObject * obj0 = 0 ;
13355 char *kwnames[] = {
13356 (char *) "self", NULL
13357 };
13358
13359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13361 if (SWIG_arg_fail(1)) SWIG_fail;
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = (bool)(arg1)->IsOk();
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13371 }
13372 return resultobj;
13373 fail:
13374 return NULL;
13375 }
13376
13377
13378 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13379 PyObject *resultobj;
13380 wxSound *arg1 = (wxSound *) 0 ;
13381 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13382 bool result;
13383 PyObject * obj0 = 0 ;
13384 PyObject * obj1 = 0 ;
13385 char *kwnames[] = {
13386 (char *) "self",(char *) "flags", NULL
13387 };
13388
13389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13391 if (SWIG_arg_fail(1)) SWIG_fail;
13392 if (obj1) {
13393 {
13394 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13395 if (SWIG_arg_fail(2)) SWIG_fail;
13396 }
13397 }
13398 {
13399 if (!wxPyCheckForApp()) SWIG_fail;
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 result = (bool)((wxSound const *)arg1)->Play(arg2);
13402
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 {
13407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13408 }
13409 return resultobj;
13410 fail:
13411 return NULL;
13412 }
13413
13414
13415 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13416 PyObject *resultobj;
13417 wxString *arg1 = 0 ;
13418 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13419 bool result;
13420 bool temp1 = false ;
13421 PyObject * obj0 = 0 ;
13422 PyObject * obj1 = 0 ;
13423 char *kwnames[] = {
13424 (char *) "filename",(char *) "flags", NULL
13425 };
13426
13427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13428 {
13429 arg1 = wxString_in_helper(obj0);
13430 if (arg1 == NULL) SWIG_fail;
13431 temp1 = true;
13432 }
13433 if (obj1) {
13434 {
13435 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13436 if (SWIG_arg_fail(2)) SWIG_fail;
13437 }
13438 }
13439 {
13440 if (!wxPyCheckForApp()) SWIG_fail;
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13443
13444 wxPyEndAllowThreads(__tstate);
13445 if (PyErr_Occurred()) SWIG_fail;
13446 }
13447 {
13448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13449 }
13450 {
13451 if (temp1)
13452 delete arg1;
13453 }
13454 return resultobj;
13455 fail:
13456 {
13457 if (temp1)
13458 delete arg1;
13459 }
13460 return NULL;
13461 }
13462
13463
13464 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13465 PyObject *resultobj;
13466 char *kwnames[] = {
13467 NULL
13468 };
13469
13470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13471 {
13472 if (!wxPyCheckForApp()) SWIG_fail;
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 wxSound::Stop();
13475
13476 wxPyEndAllowThreads(__tstate);
13477 if (PyErr_Occurred()) SWIG_fail;
13478 }
13479 Py_INCREF(Py_None); resultobj = Py_None;
13480 return resultobj;
13481 fail:
13482 return NULL;
13483 }
13484
13485
13486 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13487 PyObject *obj;
13488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13489 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13490 Py_INCREF(obj);
13491 return Py_BuildValue((char *)"");
13492 }
13493 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj;
13495 wxString *arg1 = 0 ;
13496 wxString *arg2 = 0 ;
13497 wxString *arg3 = 0 ;
13498 wxString *arg4 = 0 ;
13499 wxFileTypeInfo *result;
13500 bool temp1 = false ;
13501 bool temp2 = false ;
13502 bool temp3 = false ;
13503 bool temp4 = false ;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 PyObject * obj2 = 0 ;
13507 PyObject * obj3 = 0 ;
13508 char *kwnames[] = {
13509 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13510 };
13511
13512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13513 {
13514 arg1 = wxString_in_helper(obj0);
13515 if (arg1 == NULL) SWIG_fail;
13516 temp1 = true;
13517 }
13518 {
13519 arg2 = wxString_in_helper(obj1);
13520 if (arg2 == NULL) SWIG_fail;
13521 temp2 = true;
13522 }
13523 {
13524 arg3 = wxString_in_helper(obj2);
13525 if (arg3 == NULL) SWIG_fail;
13526 temp3 = true;
13527 }
13528 {
13529 arg4 = wxString_in_helper(obj3);
13530 if (arg4 == NULL) SWIG_fail;
13531 temp4 = true;
13532 }
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13536
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13541 {
13542 if (temp1)
13543 delete arg1;
13544 }
13545 {
13546 if (temp2)
13547 delete arg2;
13548 }
13549 {
13550 if (temp3)
13551 delete arg3;
13552 }
13553 {
13554 if (temp4)
13555 delete arg4;
13556 }
13557 return resultobj;
13558 fail:
13559 {
13560 if (temp1)
13561 delete arg1;
13562 }
13563 {
13564 if (temp2)
13565 delete arg2;
13566 }
13567 {
13568 if (temp3)
13569 delete arg3;
13570 }
13571 {
13572 if (temp4)
13573 delete arg4;
13574 }
13575 return NULL;
13576 }
13577
13578
13579 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13580 PyObject *resultobj;
13581 wxArrayString *arg1 = 0 ;
13582 wxFileTypeInfo *result;
13583 bool temp1 = false ;
13584 PyObject * obj0 = 0 ;
13585 char *kwnames[] = {
13586 (char *) "sArray", NULL
13587 };
13588
13589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13590 {
13591 if (! PySequence_Check(obj0)) {
13592 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13593 SWIG_fail;
13594 }
13595 arg1 = new wxArrayString;
13596 temp1 = true;
13597 int i, len=PySequence_Length(obj0);
13598 for (i=0; i<len; i++) {
13599 PyObject* item = PySequence_GetItem(obj0, i);
13600 #if wxUSE_UNICODE
13601 PyObject* str = PyObject_Unicode(item);
13602 #else
13603 PyObject* str = PyObject_Str(item);
13604 #endif
13605 if (PyErr_Occurred()) SWIG_fail;
13606 arg1->Add(Py2wxString(str));
13607 Py_DECREF(item);
13608 Py_DECREF(str);
13609 }
13610 }
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13614
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13619 {
13620 if (temp1) delete arg1;
13621 }
13622 return resultobj;
13623 fail:
13624 {
13625 if (temp1) delete arg1;
13626 }
13627 return NULL;
13628 }
13629
13630
13631 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13632 PyObject *resultobj;
13633 wxFileTypeInfo *result;
13634 char *kwnames[] = {
13635 NULL
13636 };
13637
13638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13656 bool result;
13657 PyObject * obj0 = 0 ;
13658 char *kwnames[] = {
13659 (char *) "self", NULL
13660 };
13661
13662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13664 if (SWIG_arg_fail(1)) SWIG_fail;
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 {
13673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13674 }
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj;
13683 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13684 wxString *arg2 = 0 ;
13685 int arg3 = (int) 0 ;
13686 bool temp2 = false ;
13687 PyObject * obj0 = 0 ;
13688 PyObject * obj1 = 0 ;
13689 PyObject * obj2 = 0 ;
13690 char *kwnames[] = {
13691 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13692 };
13693
13694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13696 if (SWIG_arg_fail(1)) SWIG_fail;
13697 {
13698 arg2 = wxString_in_helper(obj1);
13699 if (arg2 == NULL) SWIG_fail;
13700 temp2 = true;
13701 }
13702 if (obj2) {
13703 {
13704 arg3 = (int)(SWIG_As_int(obj2));
13705 if (SWIG_arg_fail(3)) SWIG_fail;
13706 }
13707 }
13708 {
13709 PyThreadState* __tstate = wxPyBeginAllowThreads();
13710 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13711
13712 wxPyEndAllowThreads(__tstate);
13713 if (PyErr_Occurred()) SWIG_fail;
13714 }
13715 Py_INCREF(Py_None); resultobj = Py_None;
13716 {
13717 if (temp2)
13718 delete arg2;
13719 }
13720 return resultobj;
13721 fail:
13722 {
13723 if (temp2)
13724 delete arg2;
13725 }
13726 return NULL;
13727 }
13728
13729
13730 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13731 PyObject *resultobj;
13732 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13733 wxString *arg2 = 0 ;
13734 bool temp2 = false ;
13735 PyObject * obj0 = 0 ;
13736 PyObject * obj1 = 0 ;
13737 char *kwnames[] = {
13738 (char *) "self",(char *) "shortDesc", NULL
13739 };
13740
13741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13743 if (SWIG_arg_fail(1)) SWIG_fail;
13744 {
13745 arg2 = wxString_in_helper(obj1);
13746 if (arg2 == NULL) SWIG_fail;
13747 temp2 = true;
13748 }
13749 {
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 (arg1)->SetShortDesc((wxString const &)*arg2);
13752
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 Py_INCREF(Py_None); resultobj = Py_None;
13757 {
13758 if (temp2)
13759 delete arg2;
13760 }
13761 return resultobj;
13762 fail:
13763 {
13764 if (temp2)
13765 delete arg2;
13766 }
13767 return NULL;
13768 }
13769
13770
13771 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj;
13773 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13774 wxString *result;
13775 PyObject * obj0 = 0 ;
13776 char *kwnames[] = {
13777 (char *) "self", NULL
13778 };
13779
13780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13782 if (SWIG_arg_fail(1)) SWIG_fail;
13783 {
13784 PyThreadState* __tstate = wxPyBeginAllowThreads();
13785 {
13786 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13787 result = (wxString *) &_result_ref;
13788 }
13789
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 {
13794 #if wxUSE_UNICODE
13795 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13796 #else
13797 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13798 #endif
13799 }
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj;
13808 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13809 wxString *result;
13810 PyObject * obj0 = 0 ;
13811 char *kwnames[] = {
13812 (char *) "self", NULL
13813 };
13814
13815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13817 if (SWIG_arg_fail(1)) SWIG_fail;
13818 {
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 {
13821 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13822 result = (wxString *) &_result_ref;
13823 }
13824
13825 wxPyEndAllowThreads(__tstate);
13826 if (PyErr_Occurred()) SWIG_fail;
13827 }
13828 {
13829 #if wxUSE_UNICODE
13830 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13831 #else
13832 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13833 #endif
13834 }
13835 return resultobj;
13836 fail:
13837 return NULL;
13838 }
13839
13840
13841 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj;
13843 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13844 wxString *result;
13845 PyObject * obj0 = 0 ;
13846 char *kwnames[] = {
13847 (char *) "self", NULL
13848 };
13849
13850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13852 if (SWIG_arg_fail(1)) SWIG_fail;
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 {
13856 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13857 result = (wxString *) &_result_ref;
13858 }
13859
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 {
13864 #if wxUSE_UNICODE
13865 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13866 #else
13867 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13868 #endif
13869 }
13870 return resultobj;
13871 fail:
13872 return NULL;
13873 }
13874
13875
13876 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj;
13878 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13879 wxString *result;
13880 PyObject * obj0 = 0 ;
13881 char *kwnames[] = {
13882 (char *) "self", NULL
13883 };
13884
13885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13887 if (SWIG_arg_fail(1)) SWIG_fail;
13888 {
13889 PyThreadState* __tstate = wxPyBeginAllowThreads();
13890 {
13891 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13892 result = (wxString *) &_result_ref;
13893 }
13894
13895 wxPyEndAllowThreads(__tstate);
13896 if (PyErr_Occurred()) SWIG_fail;
13897 }
13898 {
13899 #if wxUSE_UNICODE
13900 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13901 #else
13902 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13903 #endif
13904 }
13905 return resultobj;
13906 fail:
13907 return NULL;
13908 }
13909
13910
13911 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13912 PyObject *resultobj;
13913 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13914 wxString *result;
13915 PyObject * obj0 = 0 ;
13916 char *kwnames[] = {
13917 (char *) "self", NULL
13918 };
13919
13920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13922 if (SWIG_arg_fail(1)) SWIG_fail;
13923 {
13924 PyThreadState* __tstate = wxPyBeginAllowThreads();
13925 {
13926 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13927 result = (wxString *) &_result_ref;
13928 }
13929
13930 wxPyEndAllowThreads(__tstate);
13931 if (PyErr_Occurred()) SWIG_fail;
13932 }
13933 {
13934 #if wxUSE_UNICODE
13935 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13936 #else
13937 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13938 #endif
13939 }
13940 return resultobj;
13941 fail:
13942 return NULL;
13943 }
13944
13945
13946 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj;
13948 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13949 wxArrayString *result;
13950 PyObject * obj0 = 0 ;
13951 char *kwnames[] = {
13952 (char *) "self", NULL
13953 };
13954
13955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13957 if (SWIG_arg_fail(1)) SWIG_fail;
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 {
13961 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13962 result = (wxArrayString *) &_result_ref;
13963 }
13964
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 {
13969 resultobj = wxArrayString2PyList_helper(*result);
13970 }
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj;
13979 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13980 int result;
13981 PyObject * obj0 = 0 ;
13982 char *kwnames[] = {
13983 (char *) "self", NULL
13984 };
13985
13986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(1)) SWIG_fail;
13989 {
13990 PyThreadState* __tstate = wxPyBeginAllowThreads();
13991 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13992
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 {
13997 resultobj = SWIG_From_int((int)(result));
13998 }
13999 return resultobj;
14000 fail:
14001 return NULL;
14002 }
14003
14004
14005 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj;
14007 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14008 wxString *result;
14009 PyObject * obj0 = 0 ;
14010 char *kwnames[] = {
14011 (char *) "self", NULL
14012 };
14013
14014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14016 if (SWIG_arg_fail(1)) SWIG_fail;
14017 {
14018 PyThreadState* __tstate = wxPyBeginAllowThreads();
14019 {
14020 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14021 result = (wxString *) &_result_ref;
14022 }
14023
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 {
14028 #if wxUSE_UNICODE
14029 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14030 #else
14031 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14032 #endif
14033 }
14034 return resultobj;
14035 fail:
14036 return NULL;
14037 }
14038
14039
14040 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14041 PyObject *resultobj;
14042 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14043 int result;
14044 PyObject * obj0 = 0 ;
14045 char *kwnames[] = {
14046 (char *) "self", NULL
14047 };
14048
14049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14051 if (SWIG_arg_fail(1)) SWIG_fail;
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14055
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 {
14060 resultobj = SWIG_From_int((int)(result));
14061 }
14062 return resultobj;
14063 fail:
14064 return NULL;
14065 }
14066
14067
14068 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14069 PyObject *obj;
14070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14071 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14072 Py_INCREF(obj);
14073 return Py_BuildValue((char *)"");
14074 }
14075 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14076 PyObject *resultobj;
14077 wxFileTypeInfo *arg1 = 0 ;
14078 wxFileType *result;
14079 PyObject * obj0 = 0 ;
14080 char *kwnames[] = {
14081 (char *) "ftInfo", NULL
14082 };
14083
14084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14085 {
14086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14087 if (SWIG_arg_fail(1)) SWIG_fail;
14088 if (arg1 == NULL) {
14089 SWIG_null_ref("wxFileTypeInfo");
14090 }
14091 if (SWIG_arg_fail(1)) SWIG_fail;
14092 }
14093 {
14094 PyThreadState* __tstate = wxPyBeginAllowThreads();
14095 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14096
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14101 return resultobj;
14102 fail:
14103 return NULL;
14104 }
14105
14106
14107 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14108 PyObject *resultobj;
14109 wxFileType *arg1 = (wxFileType *) 0 ;
14110 PyObject * obj0 = 0 ;
14111 char *kwnames[] = {
14112 (char *) "self", NULL
14113 };
14114
14115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14117 if (SWIG_arg_fail(1)) SWIG_fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 delete arg1;
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 Py_INCREF(Py_None); resultobj = Py_None;
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj;
14134 wxFileType *arg1 = (wxFileType *) 0 ;
14135 PyObject *result;
14136 PyObject * obj0 = 0 ;
14137 char *kwnames[] = {
14138 (char *) "self", NULL
14139 };
14140
14141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14143 if (SWIG_arg_fail(1)) SWIG_fail;
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (PyObject *)wxFileType_GetMimeType(arg1);
14147
14148 wxPyEndAllowThreads(__tstate);
14149 if (PyErr_Occurred()) SWIG_fail;
14150 }
14151 resultobj = result;
14152 return resultobj;
14153 fail:
14154 return NULL;
14155 }
14156
14157
14158 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14159 PyObject *resultobj;
14160 wxFileType *arg1 = (wxFileType *) 0 ;
14161 PyObject *result;
14162 PyObject * obj0 = 0 ;
14163 char *kwnames[] = {
14164 (char *) "self", NULL
14165 };
14166
14167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14169 if (SWIG_arg_fail(1)) SWIG_fail;
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14173
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 resultobj = result;
14178 return resultobj;
14179 fail:
14180 return NULL;
14181 }
14182
14183
14184 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxFileType *arg1 = (wxFileType *) 0 ;
14187 PyObject *result;
14188 PyObject * obj0 = 0 ;
14189 char *kwnames[] = {
14190 (char *) "self", NULL
14191 };
14192
14193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14195 if (SWIG_arg_fail(1)) SWIG_fail;
14196 {
14197 PyThreadState* __tstate = wxPyBeginAllowThreads();
14198 result = (PyObject *)wxFileType_GetExtensions(arg1);
14199
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 resultobj = result;
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14211 PyObject *resultobj;
14212 wxFileType *arg1 = (wxFileType *) 0 ;
14213 wxIcon *result;
14214 PyObject * obj0 = 0 ;
14215 char *kwnames[] = {
14216 (char *) "self", NULL
14217 };
14218
14219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14221 if (SWIG_arg_fail(1)) SWIG_fail;
14222 {
14223 PyThreadState* __tstate = wxPyBeginAllowThreads();
14224 result = (wxIcon *)wxFileType_GetIcon(arg1);
14225
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj;
14238 wxFileType *arg1 = (wxFileType *) 0 ;
14239 PyObject *result;
14240 PyObject * obj0 = 0 ;
14241 char *kwnames[] = {
14242 (char *) "self", NULL
14243 };
14244
14245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14247 if (SWIG_arg_fail(1)) SWIG_fail;
14248 {
14249 PyThreadState* __tstate = wxPyBeginAllowThreads();
14250 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14251
14252 wxPyEndAllowThreads(__tstate);
14253 if (PyErr_Occurred()) SWIG_fail;
14254 }
14255 resultobj = result;
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14263 PyObject *resultobj;
14264 wxFileType *arg1 = (wxFileType *) 0 ;
14265 PyObject *result;
14266 PyObject * obj0 = 0 ;
14267 char *kwnames[] = {
14268 (char *) "self", NULL
14269 };
14270
14271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14273 if (SWIG_arg_fail(1)) SWIG_fail;
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 result = (PyObject *)wxFileType_GetDescription(arg1);
14277
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 resultobj = result;
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14289 PyObject *resultobj;
14290 wxFileType *arg1 = (wxFileType *) 0 ;
14291 wxString *arg2 = 0 ;
14292 wxString const &arg3_defvalue = wxPyEmptyString ;
14293 wxString *arg3 = (wxString *) &arg3_defvalue ;
14294 PyObject *result;
14295 bool temp2 = false ;
14296 bool temp3 = false ;
14297 PyObject * obj0 = 0 ;
14298 PyObject * obj1 = 0 ;
14299 PyObject * obj2 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14306 if (SWIG_arg_fail(1)) SWIG_fail;
14307 {
14308 arg2 = wxString_in_helper(obj1);
14309 if (arg2 == NULL) SWIG_fail;
14310 temp2 = true;
14311 }
14312 if (obj2) {
14313 {
14314 arg3 = wxString_in_helper(obj2);
14315 if (arg3 == NULL) SWIG_fail;
14316 temp3 = true;
14317 }
14318 }
14319 {
14320 PyThreadState* __tstate = wxPyBeginAllowThreads();
14321 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14322
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 resultobj = result;
14327 {
14328 if (temp2)
14329 delete arg2;
14330 }
14331 {
14332 if (temp3)
14333 delete arg3;
14334 }
14335 return resultobj;
14336 fail:
14337 {
14338 if (temp2)
14339 delete arg2;
14340 }
14341 {
14342 if (temp3)
14343 delete arg3;
14344 }
14345 return NULL;
14346 }
14347
14348
14349 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14350 PyObject *resultobj;
14351 wxFileType *arg1 = (wxFileType *) 0 ;
14352 wxString *arg2 = 0 ;
14353 wxString const &arg3_defvalue = wxPyEmptyString ;
14354 wxString *arg3 = (wxString *) &arg3_defvalue ;
14355 PyObject *result;
14356 bool temp2 = false ;
14357 bool temp3 = false ;
14358 PyObject * obj0 = 0 ;
14359 PyObject * obj1 = 0 ;
14360 PyObject * obj2 = 0 ;
14361 char *kwnames[] = {
14362 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14367 if (SWIG_arg_fail(1)) SWIG_fail;
14368 {
14369 arg2 = wxString_in_helper(obj1);
14370 if (arg2 == NULL) SWIG_fail;
14371 temp2 = true;
14372 }
14373 if (obj2) {
14374 {
14375 arg3 = wxString_in_helper(obj2);
14376 if (arg3 == NULL) SWIG_fail;
14377 temp3 = true;
14378 }
14379 }
14380 {
14381 PyThreadState* __tstate = wxPyBeginAllowThreads();
14382 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14383
14384 wxPyEndAllowThreads(__tstate);
14385 if (PyErr_Occurred()) SWIG_fail;
14386 }
14387 resultobj = result;
14388 {
14389 if (temp2)
14390 delete arg2;
14391 }
14392 {
14393 if (temp3)
14394 delete arg3;
14395 }
14396 return resultobj;
14397 fail:
14398 {
14399 if (temp2)
14400 delete arg2;
14401 }
14402 {
14403 if (temp3)
14404 delete arg3;
14405 }
14406 return NULL;
14407 }
14408
14409
14410 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj;
14412 wxFileType *arg1 = (wxFileType *) 0 ;
14413 wxString *arg2 = 0 ;
14414 wxString const &arg3_defvalue = wxPyEmptyString ;
14415 wxString *arg3 = (wxString *) &arg3_defvalue ;
14416 PyObject *result;
14417 bool temp2 = false ;
14418 bool temp3 = false ;
14419 PyObject * obj0 = 0 ;
14420 PyObject * obj1 = 0 ;
14421 PyObject * obj2 = 0 ;
14422 char *kwnames[] = {
14423 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14424 };
14425
14426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14428 if (SWIG_arg_fail(1)) SWIG_fail;
14429 {
14430 arg2 = wxString_in_helper(obj1);
14431 if (arg2 == NULL) SWIG_fail;
14432 temp2 = true;
14433 }
14434 if (obj2) {
14435 {
14436 arg3 = wxString_in_helper(obj2);
14437 if (arg3 == NULL) SWIG_fail;
14438 temp3 = true;
14439 }
14440 }
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14444
14445 wxPyEndAllowThreads(__tstate);
14446 if (PyErr_Occurred()) SWIG_fail;
14447 }
14448 resultobj = result;
14449 {
14450 if (temp2)
14451 delete arg2;
14452 }
14453 {
14454 if (temp3)
14455 delete arg3;
14456 }
14457 return resultobj;
14458 fail:
14459 {
14460 if (temp2)
14461 delete arg2;
14462 }
14463 {
14464 if (temp3)
14465 delete arg3;
14466 }
14467 return NULL;
14468 }
14469
14470
14471 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14472 PyObject *resultobj;
14473 wxFileType *arg1 = (wxFileType *) 0 ;
14474 wxString *arg2 = 0 ;
14475 wxString *arg3 = 0 ;
14476 bool arg4 = (bool) true ;
14477 bool result;
14478 bool temp2 = false ;
14479 bool temp3 = false ;
14480 PyObject * obj0 = 0 ;
14481 PyObject * obj1 = 0 ;
14482 PyObject * obj2 = 0 ;
14483 PyObject * obj3 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 arg2 = wxString_in_helper(obj1);
14493 if (arg2 == NULL) SWIG_fail;
14494 temp2 = true;
14495 }
14496 {
14497 arg3 = wxString_in_helper(obj2);
14498 if (arg3 == NULL) SWIG_fail;
14499 temp3 = true;
14500 }
14501 if (obj3) {
14502 {
14503 arg4 = (bool)(SWIG_As_bool(obj3));
14504 if (SWIG_arg_fail(4)) SWIG_fail;
14505 }
14506 }
14507 {
14508 PyThreadState* __tstate = wxPyBeginAllowThreads();
14509 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14510
14511 wxPyEndAllowThreads(__tstate);
14512 if (PyErr_Occurred()) SWIG_fail;
14513 }
14514 {
14515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14516 }
14517 {
14518 if (temp2)
14519 delete arg2;
14520 }
14521 {
14522 if (temp3)
14523 delete arg3;
14524 }
14525 return resultobj;
14526 fail:
14527 {
14528 if (temp2)
14529 delete arg2;
14530 }
14531 {
14532 if (temp3)
14533 delete arg3;
14534 }
14535 return NULL;
14536 }
14537
14538
14539 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14540 PyObject *resultobj;
14541 wxFileType *arg1 = (wxFileType *) 0 ;
14542 wxString const &arg2_defvalue = wxPyEmptyString ;
14543 wxString *arg2 = (wxString *) &arg2_defvalue ;
14544 int arg3 = (int) 0 ;
14545 bool result;
14546 bool temp2 = false ;
14547 PyObject * obj0 = 0 ;
14548 PyObject * obj1 = 0 ;
14549 PyObject * obj2 = 0 ;
14550 char *kwnames[] = {
14551 (char *) "self",(char *) "cmd",(char *) "index", NULL
14552 };
14553
14554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 if (obj1) {
14558 {
14559 arg2 = wxString_in_helper(obj1);
14560 if (arg2 == NULL) SWIG_fail;
14561 temp2 = true;
14562 }
14563 }
14564 if (obj2) {
14565 {
14566 arg3 = (int)(SWIG_As_int(obj2));
14567 if (SWIG_arg_fail(3)) SWIG_fail;
14568 }
14569 }
14570 {
14571 PyThreadState* __tstate = wxPyBeginAllowThreads();
14572 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14573
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 {
14578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14579 }
14580 {
14581 if (temp2)
14582 delete arg2;
14583 }
14584 return resultobj;
14585 fail:
14586 {
14587 if (temp2)
14588 delete arg2;
14589 }
14590 return NULL;
14591 }
14592
14593
14594 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj;
14596 wxFileType *arg1 = (wxFileType *) 0 ;
14597 bool result;
14598 PyObject * obj0 = 0 ;
14599 char *kwnames[] = {
14600 (char *) "self", NULL
14601 };
14602
14603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14605 if (SWIG_arg_fail(1)) SWIG_fail;
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 result = (bool)(arg1)->Unassociate();
14609
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 {
14614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14615 }
14616 return resultobj;
14617 fail:
14618 return NULL;
14619 }
14620
14621
14622 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14623 PyObject *resultobj;
14624 wxString *arg1 = 0 ;
14625 wxString *arg2 = 0 ;
14626 wxString const &arg3_defvalue = wxPyEmptyString ;
14627 wxString *arg3 = (wxString *) &arg3_defvalue ;
14628 wxString result;
14629 bool temp1 = false ;
14630 bool temp2 = false ;
14631 bool temp3 = false ;
14632 PyObject * obj0 = 0 ;
14633 PyObject * obj1 = 0 ;
14634 PyObject * obj2 = 0 ;
14635 char *kwnames[] = {
14636 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14637 };
14638
14639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14640 {
14641 arg1 = wxString_in_helper(obj0);
14642 if (arg1 == NULL) SWIG_fail;
14643 temp1 = true;
14644 }
14645 {
14646 arg2 = wxString_in_helper(obj1);
14647 if (arg2 == NULL) SWIG_fail;
14648 temp2 = true;
14649 }
14650 if (obj2) {
14651 {
14652 arg3 = wxString_in_helper(obj2);
14653 if (arg3 == NULL) SWIG_fail;
14654 temp3 = true;
14655 }
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14660
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 {
14665 #if wxUSE_UNICODE
14666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14667 #else
14668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14669 #endif
14670 }
14671 {
14672 if (temp1)
14673 delete arg1;
14674 }
14675 {
14676 if (temp2)
14677 delete arg2;
14678 }
14679 {
14680 if (temp3)
14681 delete arg3;
14682 }
14683 return resultobj;
14684 fail:
14685 {
14686 if (temp1)
14687 delete arg1;
14688 }
14689 {
14690 if (temp2)
14691 delete arg2;
14692 }
14693 {
14694 if (temp3)
14695 delete arg3;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14702 PyObject *obj;
14703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14704 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14705 Py_INCREF(obj);
14706 return Py_BuildValue((char *)"");
14707 }
14708 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14709 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14710 return 1;
14711 }
14712
14713
14714 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14715 PyObject *pyobj;
14716
14717 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14718 return pyobj;
14719 }
14720
14721
14722 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14723 PyObject *resultobj;
14724 wxString *arg1 = 0 ;
14725 wxString *arg2 = 0 ;
14726 bool result;
14727 bool temp1 = false ;
14728 bool temp2 = false ;
14729 PyObject * obj0 = 0 ;
14730 PyObject * obj1 = 0 ;
14731 char *kwnames[] = {
14732 (char *) "mimeType",(char *) "wildcard", NULL
14733 };
14734
14735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14736 {
14737 arg1 = wxString_in_helper(obj0);
14738 if (arg1 == NULL) SWIG_fail;
14739 temp1 = true;
14740 }
14741 {
14742 arg2 = wxString_in_helper(obj1);
14743 if (arg2 == NULL) SWIG_fail;
14744 temp2 = true;
14745 }
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14749
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 {
14754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14755 }
14756 {
14757 if (temp1)
14758 delete arg1;
14759 }
14760 {
14761 if (temp2)
14762 delete arg2;
14763 }
14764 return resultobj;
14765 fail:
14766 {
14767 if (temp1)
14768 delete arg1;
14769 }
14770 {
14771 if (temp2)
14772 delete arg2;
14773 }
14774 return NULL;
14775 }
14776
14777
14778 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14779 PyObject *resultobj;
14780 wxMimeTypesManager *result;
14781 char *kwnames[] = {
14782 NULL
14783 };
14784
14785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14786 {
14787 PyThreadState* __tstate = wxPyBeginAllowThreads();
14788 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14789
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14794 return resultobj;
14795 fail:
14796 return NULL;
14797 }
14798
14799
14800 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14801 PyObject *resultobj;
14802 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14803 int arg2 = (int) wxMAILCAP_ALL ;
14804 wxString const &arg3_defvalue = wxPyEmptyString ;
14805 wxString *arg3 = (wxString *) &arg3_defvalue ;
14806 bool temp3 = false ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 char *kwnames[] = {
14811 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14812 };
14813
14814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14816 if (SWIG_arg_fail(1)) SWIG_fail;
14817 if (obj1) {
14818 {
14819 arg2 = (int)(SWIG_As_int(obj1));
14820 if (SWIG_arg_fail(2)) SWIG_fail;
14821 }
14822 }
14823 if (obj2) {
14824 {
14825 arg3 = wxString_in_helper(obj2);
14826 if (arg3 == NULL) SWIG_fail;
14827 temp3 = true;
14828 }
14829 }
14830 {
14831 PyThreadState* __tstate = wxPyBeginAllowThreads();
14832 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14833
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 Py_INCREF(Py_None); resultobj = Py_None;
14838 {
14839 if (temp3)
14840 delete arg3;
14841 }
14842 return resultobj;
14843 fail:
14844 {
14845 if (temp3)
14846 delete arg3;
14847 }
14848 return NULL;
14849 }
14850
14851
14852 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14853 PyObject *resultobj;
14854 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14855 PyObject * obj0 = 0 ;
14856 char *kwnames[] = {
14857 (char *) "self", NULL
14858 };
14859
14860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14862 if (SWIG_arg_fail(1)) SWIG_fail;
14863 {
14864 PyThreadState* __tstate = wxPyBeginAllowThreads();
14865 (arg1)->ClearData();
14866
14867 wxPyEndAllowThreads(__tstate);
14868 if (PyErr_Occurred()) SWIG_fail;
14869 }
14870 Py_INCREF(Py_None); resultobj = Py_None;
14871 return resultobj;
14872 fail:
14873 return NULL;
14874 }
14875
14876
14877 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj;
14879 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14880 wxString *arg2 = 0 ;
14881 wxFileType *result;
14882 bool temp2 = false ;
14883 PyObject * obj0 = 0 ;
14884 PyObject * obj1 = 0 ;
14885 char *kwnames[] = {
14886 (char *) "self",(char *) "ext", NULL
14887 };
14888
14889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14891 if (SWIG_arg_fail(1)) SWIG_fail;
14892 {
14893 arg2 = wxString_in_helper(obj1);
14894 if (arg2 == NULL) SWIG_fail;
14895 temp2 = true;
14896 }
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14900
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14905 {
14906 if (temp2)
14907 delete arg2;
14908 }
14909 return resultobj;
14910 fail:
14911 {
14912 if (temp2)
14913 delete arg2;
14914 }
14915 return NULL;
14916 }
14917
14918
14919 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14920 PyObject *resultobj;
14921 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14922 wxString *arg2 = 0 ;
14923 wxFileType *result;
14924 bool temp2 = false ;
14925 PyObject * obj0 = 0 ;
14926 PyObject * obj1 = 0 ;
14927 char *kwnames[] = {
14928 (char *) "self",(char *) "mimeType", NULL
14929 };
14930
14931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14933 if (SWIG_arg_fail(1)) SWIG_fail;
14934 {
14935 arg2 = wxString_in_helper(obj1);
14936 if (arg2 == NULL) SWIG_fail;
14937 temp2 = true;
14938 }
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14942
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14947 {
14948 if (temp2)
14949 delete arg2;
14950 }
14951 return resultobj;
14952 fail:
14953 {
14954 if (temp2)
14955 delete arg2;
14956 }
14957 return NULL;
14958 }
14959
14960
14961 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14964 wxString *arg2 = 0 ;
14965 bool arg3 = (bool) false ;
14966 bool result;
14967 bool temp2 = false ;
14968 PyObject * obj0 = 0 ;
14969 PyObject * obj1 = 0 ;
14970 PyObject * obj2 = 0 ;
14971 char *kwnames[] = {
14972 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14973 };
14974
14975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14977 if (SWIG_arg_fail(1)) SWIG_fail;
14978 {
14979 arg2 = wxString_in_helper(obj1);
14980 if (arg2 == NULL) SWIG_fail;
14981 temp2 = true;
14982 }
14983 if (obj2) {
14984 {
14985 arg3 = (bool)(SWIG_As_bool(obj2));
14986 if (SWIG_arg_fail(3)) SWIG_fail;
14987 }
14988 }
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14992
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 {
14997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14998 }
14999 {
15000 if (temp2)
15001 delete arg2;
15002 }
15003 return resultobj;
15004 fail:
15005 {
15006 if (temp2)
15007 delete arg2;
15008 }
15009 return NULL;
15010 }
15011
15012
15013 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15014 PyObject *resultobj;
15015 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15016 wxString *arg2 = 0 ;
15017 bool result;
15018 bool temp2 = false ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 char *kwnames[] = {
15022 (char *) "self",(char *) "filename", NULL
15023 };
15024
15025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15027 if (SWIG_arg_fail(1)) SWIG_fail;
15028 {
15029 arg2 = wxString_in_helper(obj1);
15030 if (arg2 == NULL) SWIG_fail;
15031 temp2 = true;
15032 }
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 {
15041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15042 }
15043 {
15044 if (temp2)
15045 delete arg2;
15046 }
15047 return resultobj;
15048 fail:
15049 {
15050 if (temp2)
15051 delete arg2;
15052 }
15053 return NULL;
15054 }
15055
15056
15057 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15058 PyObject *resultobj;
15059 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15060 PyObject *result;
15061 PyObject * obj0 = 0 ;
15062 char *kwnames[] = {
15063 (char *) "self", NULL
15064 };
15065
15066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15068 if (SWIG_arg_fail(1)) SWIG_fail;
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15072
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 resultobj = result;
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj;
15085 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15086 wxFileTypeInfo *arg2 = 0 ;
15087 PyObject * obj0 = 0 ;
15088 PyObject * obj1 = 0 ;
15089 char *kwnames[] = {
15090 (char *) "self",(char *) "ft", NULL
15091 };
15092
15093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(1)) SWIG_fail;
15096 {
15097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15098 if (SWIG_arg_fail(2)) SWIG_fail;
15099 if (arg2 == NULL) {
15100 SWIG_null_ref("wxFileTypeInfo");
15101 }
15102 if (SWIG_arg_fail(2)) SWIG_fail;
15103 }
15104 {
15105 PyThreadState* __tstate = wxPyBeginAllowThreads();
15106 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15107
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 Py_INCREF(Py_None); resultobj = Py_None;
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj;
15120 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15121 wxFileTypeInfo *arg2 = 0 ;
15122 wxFileType *result;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 char *kwnames[] = {
15126 (char *) "self",(char *) "ftInfo", NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15131 if (SWIG_arg_fail(1)) SWIG_fail;
15132 {
15133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15134 if (SWIG_arg_fail(2)) SWIG_fail;
15135 if (arg2 == NULL) {
15136 SWIG_null_ref("wxFileTypeInfo");
15137 }
15138 if (SWIG_arg_fail(2)) SWIG_fail;
15139 }
15140 {
15141 PyThreadState* __tstate = wxPyBeginAllowThreads();
15142 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15143
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15148 return resultobj;
15149 fail:
15150 return NULL;
15151 }
15152
15153
15154 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15155 PyObject *resultobj;
15156 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15157 wxFileType *arg2 = (wxFileType *) 0 ;
15158 bool result;
15159 PyObject * obj0 = 0 ;
15160 PyObject * obj1 = 0 ;
15161 char *kwnames[] = {
15162 (char *) "self",(char *) "ft", NULL
15163 };
15164
15165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15167 if (SWIG_arg_fail(1)) SWIG_fail;
15168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15169 if (SWIG_arg_fail(2)) SWIG_fail;
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (bool)(arg1)->Unassociate(arg2);
15173
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 {
15178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15179 }
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15187 PyObject *resultobj;
15188 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15189 PyObject * obj0 = 0 ;
15190 char *kwnames[] = {
15191 (char *) "self", NULL
15192 };
15193
15194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15196 if (SWIG_arg_fail(1)) SWIG_fail;
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 delete arg1;
15200
15201 wxPyEndAllowThreads(__tstate);
15202 if (PyErr_Occurred()) SWIG_fail;
15203 }
15204 Py_INCREF(Py_None); resultobj = Py_None;
15205 return resultobj;
15206 fail:
15207 return NULL;
15208 }
15209
15210
15211 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15212 PyObject *obj;
15213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15214 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15215 Py_INCREF(obj);
15216 return Py_BuildValue((char *)"");
15217 }
15218 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15219 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15220 return 1;
15221 }
15222
15223
15224 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15225 PyObject *pyobj;
15226
15227 {
15228 #if wxUSE_UNICODE
15229 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15230 #else
15231 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15232 #endif
15233 }
15234 return pyobj;
15235 }
15236
15237
15238 static int _wrap_ART_MENU_set(PyObject *) {
15239 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15240 return 1;
15241 }
15242
15243
15244 static PyObject *_wrap_ART_MENU_get(void) {
15245 PyObject *pyobj;
15246
15247 {
15248 #if wxUSE_UNICODE
15249 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15250 #else
15251 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15252 #endif
15253 }
15254 return pyobj;
15255 }
15256
15257
15258 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15259 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15260 return 1;
15261 }
15262
15263
15264 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15265 PyObject *pyobj;
15266
15267 {
15268 #if wxUSE_UNICODE
15269 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15270 #else
15271 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15272 #endif
15273 }
15274 return pyobj;
15275 }
15276
15277
15278 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15279 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15280 return 1;
15281 }
15282
15283
15284 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15285 PyObject *pyobj;
15286
15287 {
15288 #if wxUSE_UNICODE
15289 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15290 #else
15291 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15292 #endif
15293 }
15294 return pyobj;
15295 }
15296
15297
15298 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15299 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15300 return 1;
15301 }
15302
15303
15304 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15305 PyObject *pyobj;
15306
15307 {
15308 #if wxUSE_UNICODE
15309 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15310 #else
15311 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15312 #endif
15313 }
15314 return pyobj;
15315 }
15316
15317
15318 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15319 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15320 return 1;
15321 }
15322
15323
15324 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15325 PyObject *pyobj;
15326
15327 {
15328 #if wxUSE_UNICODE
15329 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15330 #else
15331 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15332 #endif
15333 }
15334 return pyobj;
15335 }
15336
15337
15338 static int _wrap_ART_BUTTON_set(PyObject *) {
15339 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15340 return 1;
15341 }
15342
15343
15344 static PyObject *_wrap_ART_BUTTON_get(void) {
15345 PyObject *pyobj;
15346
15347 {
15348 #if wxUSE_UNICODE
15349 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15350 #else
15351 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15352 #endif
15353 }
15354 return pyobj;
15355 }
15356
15357
15358 static int _wrap_ART_OTHER_set(PyObject *) {
15359 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15360 return 1;
15361 }
15362
15363
15364 static PyObject *_wrap_ART_OTHER_get(void) {
15365 PyObject *pyobj;
15366
15367 {
15368 #if wxUSE_UNICODE
15369 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15370 #else
15371 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15372 #endif
15373 }
15374 return pyobj;
15375 }
15376
15377
15378 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15379 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15380 return 1;
15381 }
15382
15383
15384 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15385 PyObject *pyobj;
15386
15387 {
15388 #if wxUSE_UNICODE
15389 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15390 #else
15391 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15392 #endif
15393 }
15394 return pyobj;
15395 }
15396
15397
15398 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15399 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15400 return 1;
15401 }
15402
15403
15404 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15405 PyObject *pyobj;
15406
15407 {
15408 #if wxUSE_UNICODE
15409 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15410 #else
15411 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15412 #endif
15413 }
15414 return pyobj;
15415 }
15416
15417
15418 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15419 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15420 return 1;
15421 }
15422
15423
15424 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15425 PyObject *pyobj;
15426
15427 {
15428 #if wxUSE_UNICODE
15429 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15430 #else
15431 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15432 #endif
15433 }
15434 return pyobj;
15435 }
15436
15437
15438 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15439 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15440 return 1;
15441 }
15442
15443
15444 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15445 PyObject *pyobj;
15446
15447 {
15448 #if wxUSE_UNICODE
15449 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15450 #else
15451 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15452 #endif
15453 }
15454 return pyobj;
15455 }
15456
15457
15458 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15459 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15460 return 1;
15461 }
15462
15463
15464 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15465 PyObject *pyobj;
15466
15467 {
15468 #if wxUSE_UNICODE
15469 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15470 #else
15471 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15472 #endif
15473 }
15474 return pyobj;
15475 }
15476
15477
15478 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15479 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15480 return 1;
15481 }
15482
15483
15484 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15485 PyObject *pyobj;
15486
15487 {
15488 #if wxUSE_UNICODE
15489 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15490 #else
15491 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15492 #endif
15493 }
15494 return pyobj;
15495 }
15496
15497
15498 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15499 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15500 return 1;
15501 }
15502
15503
15504 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15505 PyObject *pyobj;
15506
15507 {
15508 #if wxUSE_UNICODE
15509 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15510 #else
15511 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15512 #endif
15513 }
15514 return pyobj;
15515 }
15516
15517
15518 static int _wrap_ART_GO_BACK_set(PyObject *) {
15519 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15520 return 1;
15521 }
15522
15523
15524 static PyObject *_wrap_ART_GO_BACK_get(void) {
15525 PyObject *pyobj;
15526
15527 {
15528 #if wxUSE_UNICODE
15529 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15530 #else
15531 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15532 #endif
15533 }
15534 return pyobj;
15535 }
15536
15537
15538 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15539 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15540 return 1;
15541 }
15542
15543
15544 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15545 PyObject *pyobj;
15546
15547 {
15548 #if wxUSE_UNICODE
15549 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15550 #else
15551 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15552 #endif
15553 }
15554 return pyobj;
15555 }
15556
15557
15558 static int _wrap_ART_GO_UP_set(PyObject *) {
15559 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15560 return 1;
15561 }
15562
15563
15564 static PyObject *_wrap_ART_GO_UP_get(void) {
15565 PyObject *pyobj;
15566
15567 {
15568 #if wxUSE_UNICODE
15569 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15570 #else
15571 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15572 #endif
15573 }
15574 return pyobj;
15575 }
15576
15577
15578 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15579 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15580 return 1;
15581 }
15582
15583
15584 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15585 PyObject *pyobj;
15586
15587 {
15588 #if wxUSE_UNICODE
15589 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15590 #else
15591 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15592 #endif
15593 }
15594 return pyobj;
15595 }
15596
15597
15598 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15599 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15600 return 1;
15601 }
15602
15603
15604 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15605 PyObject *pyobj;
15606
15607 {
15608 #if wxUSE_UNICODE
15609 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15610 #else
15611 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15612 #endif
15613 }
15614 return pyobj;
15615 }
15616
15617
15618 static int _wrap_ART_GO_HOME_set(PyObject *) {
15619 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15620 return 1;
15621 }
15622
15623
15624 static PyObject *_wrap_ART_GO_HOME_get(void) {
15625 PyObject *pyobj;
15626
15627 {
15628 #if wxUSE_UNICODE
15629 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15630 #else
15631 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15632 #endif
15633 }
15634 return pyobj;
15635 }
15636
15637
15638 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15639 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15640 return 1;
15641 }
15642
15643
15644 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15645 PyObject *pyobj;
15646
15647 {
15648 #if wxUSE_UNICODE
15649 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15650 #else
15651 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15652 #endif
15653 }
15654 return pyobj;
15655 }
15656
15657
15658 static int _wrap_ART_PRINT_set(PyObject *) {
15659 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15660 return 1;
15661 }
15662
15663
15664 static PyObject *_wrap_ART_PRINT_get(void) {
15665 PyObject *pyobj;
15666
15667 {
15668 #if wxUSE_UNICODE
15669 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15670 #else
15671 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15672 #endif
15673 }
15674 return pyobj;
15675 }
15676
15677
15678 static int _wrap_ART_HELP_set(PyObject *) {
15679 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15680 return 1;
15681 }
15682
15683
15684 static PyObject *_wrap_ART_HELP_get(void) {
15685 PyObject *pyobj;
15686
15687 {
15688 #if wxUSE_UNICODE
15689 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15690 #else
15691 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15692 #endif
15693 }
15694 return pyobj;
15695 }
15696
15697
15698 static int _wrap_ART_TIP_set(PyObject *) {
15699 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15700 return 1;
15701 }
15702
15703
15704 static PyObject *_wrap_ART_TIP_get(void) {
15705 PyObject *pyobj;
15706
15707 {
15708 #if wxUSE_UNICODE
15709 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15710 #else
15711 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15712 #endif
15713 }
15714 return pyobj;
15715 }
15716
15717
15718 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15719 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15720 return 1;
15721 }
15722
15723
15724 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15725 PyObject *pyobj;
15726
15727 {
15728 #if wxUSE_UNICODE
15729 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15730 #else
15731 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15732 #endif
15733 }
15734 return pyobj;
15735 }
15736
15737
15738 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15739 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15740 return 1;
15741 }
15742
15743
15744 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15745 PyObject *pyobj;
15746
15747 {
15748 #if wxUSE_UNICODE
15749 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15750 #else
15751 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15752 #endif
15753 }
15754 return pyobj;
15755 }
15756
15757
15758 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15759 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15760 return 1;
15761 }
15762
15763
15764 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15765 PyObject *pyobj;
15766
15767 {
15768 #if wxUSE_UNICODE
15769 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15770 #else
15771 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15772 #endif
15773 }
15774 return pyobj;
15775 }
15776
15777
15778 static int _wrap_ART_HARDDISK_set(PyObject *) {
15779 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15780 return 1;
15781 }
15782
15783
15784 static PyObject *_wrap_ART_HARDDISK_get(void) {
15785 PyObject *pyobj;
15786
15787 {
15788 #if wxUSE_UNICODE
15789 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15790 #else
15791 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15792 #endif
15793 }
15794 return pyobj;
15795 }
15796
15797
15798 static int _wrap_ART_FLOPPY_set(PyObject *) {
15799 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15800 return 1;
15801 }
15802
15803
15804 static PyObject *_wrap_ART_FLOPPY_get(void) {
15805 PyObject *pyobj;
15806
15807 {
15808 #if wxUSE_UNICODE
15809 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15810 #else
15811 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15812 #endif
15813 }
15814 return pyobj;
15815 }
15816
15817
15818 static int _wrap_ART_CDROM_set(PyObject *) {
15819 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15820 return 1;
15821 }
15822
15823
15824 static PyObject *_wrap_ART_CDROM_get(void) {
15825 PyObject *pyobj;
15826
15827 {
15828 #if wxUSE_UNICODE
15829 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15830 #else
15831 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15832 #endif
15833 }
15834 return pyobj;
15835 }
15836
15837
15838 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15839 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15840 return 1;
15841 }
15842
15843
15844 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15845 PyObject *pyobj;
15846
15847 {
15848 #if wxUSE_UNICODE
15849 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15850 #else
15851 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15852 #endif
15853 }
15854 return pyobj;
15855 }
15856
15857
15858 static int _wrap_ART_FOLDER_set(PyObject *) {
15859 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15860 return 1;
15861 }
15862
15863
15864 static PyObject *_wrap_ART_FOLDER_get(void) {
15865 PyObject *pyobj;
15866
15867 {
15868 #if wxUSE_UNICODE
15869 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15870 #else
15871 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15872 #endif
15873 }
15874 return pyobj;
15875 }
15876
15877
15878 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15879 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15880 return 1;
15881 }
15882
15883
15884 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15885 PyObject *pyobj;
15886
15887 {
15888 #if wxUSE_UNICODE
15889 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15890 #else
15891 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15892 #endif
15893 }
15894 return pyobj;
15895 }
15896
15897
15898 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15899 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15900 return 1;
15901 }
15902
15903
15904 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15905 PyObject *pyobj;
15906
15907 {
15908 #if wxUSE_UNICODE
15909 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15910 #else
15911 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15912 #endif
15913 }
15914 return pyobj;
15915 }
15916
15917
15918 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15919 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15920 return 1;
15921 }
15922
15923
15924 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15925 PyObject *pyobj;
15926
15927 {
15928 #if wxUSE_UNICODE
15929 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15930 #else
15931 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15932 #endif
15933 }
15934 return pyobj;
15935 }
15936
15937
15938 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15939 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15940 return 1;
15941 }
15942
15943
15944 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15945 PyObject *pyobj;
15946
15947 {
15948 #if wxUSE_UNICODE
15949 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15950 #else
15951 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15952 #endif
15953 }
15954 return pyobj;
15955 }
15956
15957
15958 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15959 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15960 return 1;
15961 }
15962
15963
15964 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15965 PyObject *pyobj;
15966
15967 {
15968 #if wxUSE_UNICODE
15969 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15970 #else
15971 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15972 #endif
15973 }
15974 return pyobj;
15975 }
15976
15977
15978 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15979 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15980 return 1;
15981 }
15982
15983
15984 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15985 PyObject *pyobj;
15986
15987 {
15988 #if wxUSE_UNICODE
15989 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15990 #else
15991 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15992 #endif
15993 }
15994 return pyobj;
15995 }
15996
15997
15998 static int _wrap_ART_ERROR_set(PyObject *) {
15999 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16000 return 1;
16001 }
16002
16003
16004 static PyObject *_wrap_ART_ERROR_get(void) {
16005 PyObject *pyobj;
16006
16007 {
16008 #if wxUSE_UNICODE
16009 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16010 #else
16011 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16012 #endif
16013 }
16014 return pyobj;
16015 }
16016
16017
16018 static int _wrap_ART_QUESTION_set(PyObject *) {
16019 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16020 return 1;
16021 }
16022
16023
16024 static PyObject *_wrap_ART_QUESTION_get(void) {
16025 PyObject *pyobj;
16026
16027 {
16028 #if wxUSE_UNICODE
16029 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16030 #else
16031 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16032 #endif
16033 }
16034 return pyobj;
16035 }
16036
16037
16038 static int _wrap_ART_WARNING_set(PyObject *) {
16039 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16040 return 1;
16041 }
16042
16043
16044 static PyObject *_wrap_ART_WARNING_get(void) {
16045 PyObject *pyobj;
16046
16047 {
16048 #if wxUSE_UNICODE
16049 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16050 #else
16051 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16052 #endif
16053 }
16054 return pyobj;
16055 }
16056
16057
16058 static int _wrap_ART_INFORMATION_set(PyObject *) {
16059 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16060 return 1;
16061 }
16062
16063
16064 static PyObject *_wrap_ART_INFORMATION_get(void) {
16065 PyObject *pyobj;
16066
16067 {
16068 #if wxUSE_UNICODE
16069 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16070 #else
16071 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16072 #endif
16073 }
16074 return pyobj;
16075 }
16076
16077
16078 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16079 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16080 return 1;
16081 }
16082
16083
16084 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16085 PyObject *pyobj;
16086
16087 {
16088 #if wxUSE_UNICODE
16089 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16090 #else
16091 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16092 #endif
16093 }
16094 return pyobj;
16095 }
16096
16097
16098 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16099 PyObject *resultobj;
16100 wxPyArtProvider *result;
16101 char *kwnames[] = {
16102 NULL
16103 };
16104
16105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16106 {
16107 if (!wxPyCheckForApp()) SWIG_fail;
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 result = (wxPyArtProvider *)new wxPyArtProvider();
16110
16111 wxPyEndAllowThreads(__tstate);
16112 if (PyErr_Occurred()) SWIG_fail;
16113 }
16114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16115 return resultobj;
16116 fail:
16117 return NULL;
16118 }
16119
16120
16121 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16122 PyObject *resultobj;
16123 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16124 PyObject *arg2 = (PyObject *) 0 ;
16125 PyObject *arg3 = (PyObject *) 0 ;
16126 PyObject * obj0 = 0 ;
16127 PyObject * obj1 = 0 ;
16128 PyObject * obj2 = 0 ;
16129 char *kwnames[] = {
16130 (char *) "self",(char *) "self",(char *) "_class", NULL
16131 };
16132
16133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16135 if (SWIG_arg_fail(1)) SWIG_fail;
16136 arg2 = obj1;
16137 arg3 = obj2;
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 (arg1)->_setCallbackInfo(arg2,arg3);
16141
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 Py_INCREF(Py_None); resultobj = Py_None;
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16153 PyObject *resultobj;
16154 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16155 PyObject * obj0 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "provider", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 wxPyArtProvider::PushProvider(arg1);
16166
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 Py_INCREF(Py_None); resultobj = Py_None;
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16178 PyObject *resultobj;
16179 bool result;
16180 char *kwnames[] = {
16181 NULL
16182 };
16183
16184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16185 {
16186 PyThreadState* __tstate = wxPyBeginAllowThreads();
16187 result = (bool)wxPyArtProvider::PopProvider();
16188
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 {
16193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16194 }
16195 return resultobj;
16196 fail:
16197 return NULL;
16198 }
16199
16200
16201 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16202 PyObject *resultobj;
16203 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16204 bool result;
16205 PyObject * obj0 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "provider", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16216
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 {
16221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16222 }
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj;
16231 wxString *arg1 = 0 ;
16232 wxString const &arg2_defvalue = wxPyART_OTHER ;
16233 wxString *arg2 = (wxString *) &arg2_defvalue ;
16234 wxSize const &arg3_defvalue = wxDefaultSize ;
16235 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16236 wxBitmap result;
16237 bool temp1 = false ;
16238 bool temp2 = false ;
16239 wxSize temp3 ;
16240 PyObject * obj0 = 0 ;
16241 PyObject * obj1 = 0 ;
16242 PyObject * obj2 = 0 ;
16243 char *kwnames[] = {
16244 (char *) "id",(char *) "client",(char *) "size", NULL
16245 };
16246
16247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16248 {
16249 arg1 = wxString_in_helper(obj0);
16250 if (arg1 == NULL) SWIG_fail;
16251 temp1 = true;
16252 }
16253 if (obj1) {
16254 {
16255 arg2 = wxString_in_helper(obj1);
16256 if (arg2 == NULL) SWIG_fail;
16257 temp2 = true;
16258 }
16259 }
16260 if (obj2) {
16261 {
16262 arg3 = &temp3;
16263 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16264 }
16265 }
16266 {
16267 if (!wxPyCheckForApp()) SWIG_fail;
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16270
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 wxBitmap * resultptr;
16276 resultptr = new wxBitmap((wxBitmap &)(result));
16277 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16278 }
16279 {
16280 if (temp1)
16281 delete arg1;
16282 }
16283 {
16284 if (temp2)
16285 delete arg2;
16286 }
16287 return resultobj;
16288 fail:
16289 {
16290 if (temp1)
16291 delete arg1;
16292 }
16293 {
16294 if (temp2)
16295 delete arg2;
16296 }
16297 return NULL;
16298 }
16299
16300
16301 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16302 PyObject *resultobj;
16303 wxString *arg1 = 0 ;
16304 wxString const &arg2_defvalue = wxPyART_OTHER ;
16305 wxString *arg2 = (wxString *) &arg2_defvalue ;
16306 wxSize const &arg3_defvalue = wxDefaultSize ;
16307 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16308 wxIcon result;
16309 bool temp1 = false ;
16310 bool temp2 = false ;
16311 wxSize temp3 ;
16312 PyObject * obj0 = 0 ;
16313 PyObject * obj1 = 0 ;
16314 PyObject * obj2 = 0 ;
16315 char *kwnames[] = {
16316 (char *) "id",(char *) "client",(char *) "size", NULL
16317 };
16318
16319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16320 {
16321 arg1 = wxString_in_helper(obj0);
16322 if (arg1 == NULL) SWIG_fail;
16323 temp1 = true;
16324 }
16325 if (obj1) {
16326 {
16327 arg2 = wxString_in_helper(obj1);
16328 if (arg2 == NULL) SWIG_fail;
16329 temp2 = true;
16330 }
16331 }
16332 if (obj2) {
16333 {
16334 arg3 = &temp3;
16335 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16336 }
16337 }
16338 {
16339 if (!wxPyCheckForApp()) SWIG_fail;
16340 PyThreadState* __tstate = wxPyBeginAllowThreads();
16341 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16342
16343 wxPyEndAllowThreads(__tstate);
16344 if (PyErr_Occurred()) SWIG_fail;
16345 }
16346 {
16347 wxIcon * resultptr;
16348 resultptr = new wxIcon((wxIcon &)(result));
16349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16350 }
16351 {
16352 if (temp1)
16353 delete arg1;
16354 }
16355 {
16356 if (temp2)
16357 delete arg2;
16358 }
16359 return resultobj;
16360 fail:
16361 {
16362 if (temp1)
16363 delete arg1;
16364 }
16365 {
16366 if (temp2)
16367 delete arg2;
16368 }
16369 return NULL;
16370 }
16371
16372
16373 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16374 PyObject *resultobj;
16375 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16376 PyObject * obj0 = 0 ;
16377 char *kwnames[] = {
16378 (char *) "self", NULL
16379 };
16380
16381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16383 if (SWIG_arg_fail(1)) SWIG_fail;
16384 {
16385 PyThreadState* __tstate = wxPyBeginAllowThreads();
16386 wxPyArtProvider_Destroy(arg1);
16387
16388 wxPyEndAllowThreads(__tstate);
16389 if (PyErr_Occurred()) SWIG_fail;
16390 }
16391 Py_INCREF(Py_None); resultobj = Py_None;
16392 return resultobj;
16393 fail:
16394 return NULL;
16395 }
16396
16397
16398 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16399 PyObject *obj;
16400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16401 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16402 Py_INCREF(obj);
16403 return Py_BuildValue((char *)"");
16404 }
16405 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16406 PyObject *resultobj;
16407 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16408 PyObject * obj0 = 0 ;
16409 char *kwnames[] = {
16410 (char *) "self", NULL
16411 };
16412
16413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16415 if (SWIG_arg_fail(1)) SWIG_fail;
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 delete arg1;
16419
16420 wxPyEndAllowThreads(__tstate);
16421 if (PyErr_Occurred()) SWIG_fail;
16422 }
16423 Py_INCREF(Py_None); resultobj = Py_None;
16424 return resultobj;
16425 fail:
16426 return NULL;
16427 }
16428
16429
16430 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16431 PyObject *resultobj;
16432 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16433 wxConfigBase *result;
16434 PyObject * obj0 = 0 ;
16435 char *kwnames[] = {
16436 (char *) "config", NULL
16437 };
16438
16439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16441 if (SWIG_arg_fail(1)) SWIG_fail;
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16445
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj;
16458 bool arg1 = (bool) true ;
16459 wxConfigBase *result;
16460 PyObject * obj0 = 0 ;
16461 char *kwnames[] = {
16462 (char *) "createOnDemand", NULL
16463 };
16464
16465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16466 if (obj0) {
16467 {
16468 arg1 = (bool)(SWIG_As_bool(obj0));
16469 if (SWIG_arg_fail(1)) SWIG_fail;
16470 }
16471 }
16472 {
16473 PyThreadState* __tstate = wxPyBeginAllowThreads();
16474 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16475
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16487 PyObject *resultobj;
16488 wxConfigBase *result;
16489 char *kwnames[] = {
16490 NULL
16491 };
16492
16493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (wxConfigBase *)wxConfigBase::Create();
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16509 PyObject *resultobj;
16510 char *kwnames[] = {
16511 NULL
16512 };
16513
16514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16515 {
16516 PyThreadState* __tstate = wxPyBeginAllowThreads();
16517 wxConfigBase::DontCreateOnDemand();
16518
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 Py_INCREF(Py_None); resultobj = Py_None;
16523 return resultobj;
16524 fail:
16525 return NULL;
16526 }
16527
16528
16529 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16530 PyObject *resultobj;
16531 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16532 wxString *arg2 = 0 ;
16533 bool temp2 = false ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 char *kwnames[] = {
16537 (char *) "self",(char *) "path", NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16542 if (SWIG_arg_fail(1)) SWIG_fail;
16543 {
16544 arg2 = wxString_in_helper(obj1);
16545 if (arg2 == NULL) SWIG_fail;
16546 temp2 = true;
16547 }
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 (arg1)->SetPath((wxString const &)*arg2);
16551
16552 wxPyEndAllowThreads(__tstate);
16553 if (PyErr_Occurred()) SWIG_fail;
16554 }
16555 Py_INCREF(Py_None); resultobj = Py_None;
16556 {
16557 if (temp2)
16558 delete arg2;
16559 }
16560 return resultobj;
16561 fail:
16562 {
16563 if (temp2)
16564 delete arg2;
16565 }
16566 return NULL;
16567 }
16568
16569
16570 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj;
16572 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16573 wxString *result;
16574 PyObject * obj0 = 0 ;
16575 char *kwnames[] = {
16576 (char *) "self", NULL
16577 };
16578
16579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16581 if (SWIG_arg_fail(1)) SWIG_fail;
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 {
16585 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16586 result = (wxString *) &_result_ref;
16587 }
16588
16589 wxPyEndAllowThreads(__tstate);
16590 if (PyErr_Occurred()) SWIG_fail;
16591 }
16592 {
16593 #if wxUSE_UNICODE
16594 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16595 #else
16596 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16597 #endif
16598 }
16599 return resultobj;
16600 fail:
16601 return NULL;
16602 }
16603
16604
16605 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj;
16607 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16608 PyObject *result;
16609 PyObject * obj0 = 0 ;
16610 char *kwnames[] = {
16611 (char *) "self", NULL
16612 };
16613
16614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16616 if (SWIG_arg_fail(1)) SWIG_fail;
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16620
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 resultobj = result;
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj;
16633 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16634 long arg2 ;
16635 PyObject *result;
16636 PyObject * obj0 = 0 ;
16637 PyObject * obj1 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self",(char *) "index", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 arg2 = (long)(SWIG_As_long(obj1));
16647 if (SWIG_arg_fail(2)) SWIG_fail;
16648 }
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16652
16653 wxPyEndAllowThreads(__tstate);
16654 if (PyErr_Occurred()) SWIG_fail;
16655 }
16656 resultobj = result;
16657 return resultobj;
16658 fail:
16659 return NULL;
16660 }
16661
16662
16663 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16664 PyObject *resultobj;
16665 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16666 PyObject *result;
16667 PyObject * obj0 = 0 ;
16668 char *kwnames[] = {
16669 (char *) "self", NULL
16670 };
16671
16672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16674 if (SWIG_arg_fail(1)) SWIG_fail;
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16678
16679 wxPyEndAllowThreads(__tstate);
16680 if (PyErr_Occurred()) SWIG_fail;
16681 }
16682 resultobj = result;
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj;
16691 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16692 long arg2 ;
16693 PyObject *result;
16694 PyObject * obj0 = 0 ;
16695 PyObject * obj1 = 0 ;
16696 char *kwnames[] = {
16697 (char *) "self",(char *) "index", NULL
16698 };
16699
16700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16702 if (SWIG_arg_fail(1)) SWIG_fail;
16703 {
16704 arg2 = (long)(SWIG_As_long(obj1));
16705 if (SWIG_arg_fail(2)) SWIG_fail;
16706 }
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16710
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 resultobj = result;
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16722 PyObject *resultobj;
16723 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16724 bool arg2 = (bool) false ;
16725 size_t result;
16726 PyObject * obj0 = 0 ;
16727 PyObject * obj1 = 0 ;
16728 char *kwnames[] = {
16729 (char *) "self",(char *) "recursive", NULL
16730 };
16731
16732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16734 if (SWIG_arg_fail(1)) SWIG_fail;
16735 if (obj1) {
16736 {
16737 arg2 = (bool)(SWIG_As_bool(obj1));
16738 if (SWIG_arg_fail(2)) SWIG_fail;
16739 }
16740 }
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16744
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 {
16749 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16750 }
16751 return resultobj;
16752 fail:
16753 return NULL;
16754 }
16755
16756
16757 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16758 PyObject *resultobj;
16759 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16760 bool arg2 = (bool) false ;
16761 size_t result;
16762 PyObject * obj0 = 0 ;
16763 PyObject * obj1 = 0 ;
16764 char *kwnames[] = {
16765 (char *) "self",(char *) "recursive", NULL
16766 };
16767
16768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16770 if (SWIG_arg_fail(1)) SWIG_fail;
16771 if (obj1) {
16772 {
16773 arg2 = (bool)(SWIG_As_bool(obj1));
16774 if (SWIG_arg_fail(2)) SWIG_fail;
16775 }
16776 }
16777 {
16778 PyThreadState* __tstate = wxPyBeginAllowThreads();
16779 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16780
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 {
16785 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16786 }
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16794 PyObject *resultobj;
16795 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16796 wxString *arg2 = 0 ;
16797 bool result;
16798 bool temp2 = false ;
16799 PyObject * obj0 = 0 ;
16800 PyObject * obj1 = 0 ;
16801 char *kwnames[] = {
16802 (char *) "self",(char *) "name", NULL
16803 };
16804
16805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16807 if (SWIG_arg_fail(1)) SWIG_fail;
16808 {
16809 arg2 = wxString_in_helper(obj1);
16810 if (arg2 == NULL) SWIG_fail;
16811 temp2 = true;
16812 }
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16816
16817 wxPyEndAllowThreads(__tstate);
16818 if (PyErr_Occurred()) SWIG_fail;
16819 }
16820 {
16821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16822 }
16823 {
16824 if (temp2)
16825 delete arg2;
16826 }
16827 return resultobj;
16828 fail:
16829 {
16830 if (temp2)
16831 delete arg2;
16832 }
16833 return NULL;
16834 }
16835
16836
16837 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj;
16839 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16840 wxString *arg2 = 0 ;
16841 bool result;
16842 bool temp2 = false ;
16843 PyObject * obj0 = 0 ;
16844 PyObject * obj1 = 0 ;
16845 char *kwnames[] = {
16846 (char *) "self",(char *) "name", NULL
16847 };
16848
16849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16851 if (SWIG_arg_fail(1)) SWIG_fail;
16852 {
16853 arg2 = wxString_in_helper(obj1);
16854 if (arg2 == NULL) SWIG_fail;
16855 temp2 = true;
16856 }
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 {
16865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16866 }
16867 {
16868 if (temp2)
16869 delete arg2;
16870 }
16871 return resultobj;
16872 fail:
16873 {
16874 if (temp2)
16875 delete arg2;
16876 }
16877 return NULL;
16878 }
16879
16880
16881 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16882 PyObject *resultobj;
16883 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16884 wxString *arg2 = 0 ;
16885 bool result;
16886 bool temp2 = false ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "self",(char *) "name", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16895 if (SWIG_arg_fail(1)) SWIG_fail;
16896 {
16897 arg2 = wxString_in_helper(obj1);
16898 if (arg2 == NULL) SWIG_fail;
16899 temp2 = true;
16900 }
16901 {
16902 PyThreadState* __tstate = wxPyBeginAllowThreads();
16903 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16904
16905 wxPyEndAllowThreads(__tstate);
16906 if (PyErr_Occurred()) SWIG_fail;
16907 }
16908 {
16909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16910 }
16911 {
16912 if (temp2)
16913 delete arg2;
16914 }
16915 return resultobj;
16916 fail:
16917 {
16918 if (temp2)
16919 delete arg2;
16920 }
16921 return NULL;
16922 }
16923
16924
16925 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16926 PyObject *resultobj;
16927 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16928 wxString *arg2 = 0 ;
16929 wxConfigBase::EntryType result;
16930 bool temp2 = false ;
16931 PyObject * obj0 = 0 ;
16932 PyObject * obj1 = 0 ;
16933 char *kwnames[] = {
16934 (char *) "self",(char *) "name", NULL
16935 };
16936
16937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16939 if (SWIG_arg_fail(1)) SWIG_fail;
16940 {
16941 arg2 = wxString_in_helper(obj1);
16942 if (arg2 == NULL) SWIG_fail;
16943 temp2 = true;
16944 }
16945 {
16946 PyThreadState* __tstate = wxPyBeginAllowThreads();
16947 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16948
16949 wxPyEndAllowThreads(__tstate);
16950 if (PyErr_Occurred()) SWIG_fail;
16951 }
16952 resultobj = SWIG_From_int((result));
16953 {
16954 if (temp2)
16955 delete arg2;
16956 }
16957 return resultobj;
16958 fail:
16959 {
16960 if (temp2)
16961 delete arg2;
16962 }
16963 return NULL;
16964 }
16965
16966
16967 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16968 PyObject *resultobj;
16969 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16970 wxString *arg2 = 0 ;
16971 wxString const &arg3_defvalue = wxPyEmptyString ;
16972 wxString *arg3 = (wxString *) &arg3_defvalue ;
16973 wxString result;
16974 bool temp2 = false ;
16975 bool temp3 = false ;
16976 PyObject * obj0 = 0 ;
16977 PyObject * obj1 = 0 ;
16978 PyObject * obj2 = 0 ;
16979 char *kwnames[] = {
16980 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16981 };
16982
16983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16985 if (SWIG_arg_fail(1)) SWIG_fail;
16986 {
16987 arg2 = wxString_in_helper(obj1);
16988 if (arg2 == NULL) SWIG_fail;
16989 temp2 = true;
16990 }
16991 if (obj2) {
16992 {
16993 arg3 = wxString_in_helper(obj2);
16994 if (arg3 == NULL) SWIG_fail;
16995 temp3 = true;
16996 }
16997 }
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 #if wxUSE_UNICODE
17007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17008 #else
17009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17010 #endif
17011 }
17012 {
17013 if (temp2)
17014 delete arg2;
17015 }
17016 {
17017 if (temp3)
17018 delete arg3;
17019 }
17020 return resultobj;
17021 fail:
17022 {
17023 if (temp2)
17024 delete arg2;
17025 }
17026 {
17027 if (temp3)
17028 delete arg3;
17029 }
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17037 wxString *arg2 = 0 ;
17038 long arg3 = (long) 0 ;
17039 long result;
17040 bool temp2 = false ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 PyObject * obj2 = 0 ;
17044 char *kwnames[] = {
17045 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17046 };
17047
17048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17050 if (SWIG_arg_fail(1)) SWIG_fail;
17051 {
17052 arg2 = wxString_in_helper(obj1);
17053 if (arg2 == NULL) SWIG_fail;
17054 temp2 = true;
17055 }
17056 if (obj2) {
17057 {
17058 arg3 = (long)(SWIG_As_long(obj2));
17059 if (SWIG_arg_fail(3)) SWIG_fail;
17060 }
17061 }
17062 {
17063 PyThreadState* __tstate = wxPyBeginAllowThreads();
17064 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17065
17066 wxPyEndAllowThreads(__tstate);
17067 if (PyErr_Occurred()) SWIG_fail;
17068 }
17069 {
17070 resultobj = SWIG_From_long((long)(result));
17071 }
17072 {
17073 if (temp2)
17074 delete arg2;
17075 }
17076 return resultobj;
17077 fail:
17078 {
17079 if (temp2)
17080 delete arg2;
17081 }
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17089 wxString *arg2 = 0 ;
17090 double arg3 = (double) 0.0 ;
17091 double result;
17092 bool temp2 = false ;
17093 PyObject * obj0 = 0 ;
17094 PyObject * obj1 = 0 ;
17095 PyObject * obj2 = 0 ;
17096 char *kwnames[] = {
17097 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17098 };
17099
17100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17102 if (SWIG_arg_fail(1)) SWIG_fail;
17103 {
17104 arg2 = wxString_in_helper(obj1);
17105 if (arg2 == NULL) SWIG_fail;
17106 temp2 = true;
17107 }
17108 if (obj2) {
17109 {
17110 arg3 = (double)(SWIG_As_double(obj2));
17111 if (SWIG_arg_fail(3)) SWIG_fail;
17112 }
17113 }
17114 {
17115 PyThreadState* __tstate = wxPyBeginAllowThreads();
17116 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17117
17118 wxPyEndAllowThreads(__tstate);
17119 if (PyErr_Occurred()) SWIG_fail;
17120 }
17121 {
17122 resultobj = SWIG_From_double((double)(result));
17123 }
17124 {
17125 if (temp2)
17126 delete arg2;
17127 }
17128 return resultobj;
17129 fail:
17130 {
17131 if (temp2)
17132 delete arg2;
17133 }
17134 return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj;
17140 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17141 wxString *arg2 = 0 ;
17142 bool arg3 = (bool) false ;
17143 bool result;
17144 bool temp2 = false ;
17145 PyObject * obj0 = 0 ;
17146 PyObject * obj1 = 0 ;
17147 PyObject * obj2 = 0 ;
17148 char *kwnames[] = {
17149 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17150 };
17151
17152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17154 if (SWIG_arg_fail(1)) SWIG_fail;
17155 {
17156 arg2 = wxString_in_helper(obj1);
17157 if (arg2 == NULL) SWIG_fail;
17158 temp2 = true;
17159 }
17160 if (obj2) {
17161 {
17162 arg3 = (bool)(SWIG_As_bool(obj2));
17163 if (SWIG_arg_fail(3)) SWIG_fail;
17164 }
17165 }
17166 {
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 {
17174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17175 }
17176 {
17177 if (temp2)
17178 delete arg2;
17179 }
17180 return resultobj;
17181 fail:
17182 {
17183 if (temp2)
17184 delete arg2;
17185 }
17186 return NULL;
17187 }
17188
17189
17190 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17191 PyObject *resultobj;
17192 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17193 wxString *arg2 = 0 ;
17194 wxString *arg3 = 0 ;
17195 bool result;
17196 bool temp2 = false ;
17197 bool temp3 = false ;
17198 PyObject * obj0 = 0 ;
17199 PyObject * obj1 = 0 ;
17200 PyObject * obj2 = 0 ;
17201 char *kwnames[] = {
17202 (char *) "self",(char *) "key",(char *) "value", NULL
17203 };
17204
17205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17207 if (SWIG_arg_fail(1)) SWIG_fail;
17208 {
17209 arg2 = wxString_in_helper(obj1);
17210 if (arg2 == NULL) SWIG_fail;
17211 temp2 = true;
17212 }
17213 {
17214 arg3 = wxString_in_helper(obj2);
17215 if (arg3 == NULL) SWIG_fail;
17216 temp3 = true;
17217 }
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17221
17222 wxPyEndAllowThreads(__tstate);
17223 if (PyErr_Occurred()) SWIG_fail;
17224 }
17225 {
17226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17227 }
17228 {
17229 if (temp2)
17230 delete arg2;
17231 }
17232 {
17233 if (temp3)
17234 delete arg3;
17235 }
17236 return resultobj;
17237 fail:
17238 {
17239 if (temp2)
17240 delete arg2;
17241 }
17242 {
17243 if (temp3)
17244 delete arg3;
17245 }
17246 return NULL;
17247 }
17248
17249
17250 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17251 PyObject *resultobj;
17252 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17253 wxString *arg2 = 0 ;
17254 long arg3 ;
17255 bool result;
17256 bool temp2 = false ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 PyObject * obj2 = 0 ;
17260 char *kwnames[] = {
17261 (char *) "self",(char *) "key",(char *) "value", NULL
17262 };
17263
17264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17266 if (SWIG_arg_fail(1)) SWIG_fail;
17267 {
17268 arg2 = wxString_in_helper(obj1);
17269 if (arg2 == NULL) SWIG_fail;
17270 temp2 = true;
17271 }
17272 {
17273 arg3 = (long)(SWIG_As_long(obj2));
17274 if (SWIG_arg_fail(3)) SWIG_fail;
17275 }
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17279
17280 wxPyEndAllowThreads(__tstate);
17281 if (PyErr_Occurred()) SWIG_fail;
17282 }
17283 {
17284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17285 }
17286 {
17287 if (temp2)
17288 delete arg2;
17289 }
17290 return resultobj;
17291 fail:
17292 {
17293 if (temp2)
17294 delete arg2;
17295 }
17296 return NULL;
17297 }
17298
17299
17300 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17301 PyObject *resultobj;
17302 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17303 wxString *arg2 = 0 ;
17304 double arg3 ;
17305 bool result;
17306 bool temp2 = false ;
17307 PyObject * obj0 = 0 ;
17308 PyObject * obj1 = 0 ;
17309 PyObject * obj2 = 0 ;
17310 char *kwnames[] = {
17311 (char *) "self",(char *) "key",(char *) "value", NULL
17312 };
17313
17314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(1)) SWIG_fail;
17317 {
17318 arg2 = wxString_in_helper(obj1);
17319 if (arg2 == NULL) SWIG_fail;
17320 temp2 = true;
17321 }
17322 {
17323 arg3 = (double)(SWIG_As_double(obj2));
17324 if (SWIG_arg_fail(3)) SWIG_fail;
17325 }
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17329
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 {
17334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17335 }
17336 {
17337 if (temp2)
17338 delete arg2;
17339 }
17340 return resultobj;
17341 fail:
17342 {
17343 if (temp2)
17344 delete arg2;
17345 }
17346 return NULL;
17347 }
17348
17349
17350 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17351 PyObject *resultobj;
17352 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17353 wxString *arg2 = 0 ;
17354 bool arg3 ;
17355 bool result;
17356 bool temp2 = false ;
17357 PyObject * obj0 = 0 ;
17358 PyObject * obj1 = 0 ;
17359 PyObject * obj2 = 0 ;
17360 char *kwnames[] = {
17361 (char *) "self",(char *) "key",(char *) "value", NULL
17362 };
17363
17364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17366 if (SWIG_arg_fail(1)) SWIG_fail;
17367 {
17368 arg2 = wxString_in_helper(obj1);
17369 if (arg2 == NULL) SWIG_fail;
17370 temp2 = true;
17371 }
17372 {
17373 arg3 = (bool)(SWIG_As_bool(obj2));
17374 if (SWIG_arg_fail(3)) SWIG_fail;
17375 }
17376 {
17377 PyThreadState* __tstate = wxPyBeginAllowThreads();
17378 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17379
17380 wxPyEndAllowThreads(__tstate);
17381 if (PyErr_Occurred()) SWIG_fail;
17382 }
17383 {
17384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17385 }
17386 {
17387 if (temp2)
17388 delete arg2;
17389 }
17390 return resultobj;
17391 fail:
17392 {
17393 if (temp2)
17394 delete arg2;
17395 }
17396 return NULL;
17397 }
17398
17399
17400 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17401 PyObject *resultobj;
17402 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17403 bool arg2 = (bool) false ;
17404 bool result;
17405 PyObject * obj0 = 0 ;
17406 PyObject * obj1 = 0 ;
17407 char *kwnames[] = {
17408 (char *) "self",(char *) "currentOnly", NULL
17409 };
17410
17411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17413 if (SWIG_arg_fail(1)) SWIG_fail;
17414 if (obj1) {
17415 {
17416 arg2 = (bool)(SWIG_As_bool(obj1));
17417 if (SWIG_arg_fail(2)) SWIG_fail;
17418 }
17419 }
17420 {
17421 PyThreadState* __tstate = wxPyBeginAllowThreads();
17422 result = (bool)(arg1)->Flush(arg2);
17423
17424 wxPyEndAllowThreads(__tstate);
17425 if (PyErr_Occurred()) SWIG_fail;
17426 }
17427 {
17428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17429 }
17430 return resultobj;
17431 fail:
17432 return NULL;
17433 }
17434
17435
17436 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17437 PyObject *resultobj;
17438 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17439 wxString *arg2 = 0 ;
17440 wxString *arg3 = 0 ;
17441 bool result;
17442 bool temp2 = false ;
17443 bool temp3 = false ;
17444 PyObject * obj0 = 0 ;
17445 PyObject * obj1 = 0 ;
17446 PyObject * obj2 = 0 ;
17447 char *kwnames[] = {
17448 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17449 };
17450
17451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17453 if (SWIG_arg_fail(1)) SWIG_fail;
17454 {
17455 arg2 = wxString_in_helper(obj1);
17456 if (arg2 == NULL) SWIG_fail;
17457 temp2 = true;
17458 }
17459 {
17460 arg3 = wxString_in_helper(obj2);
17461 if (arg3 == NULL) SWIG_fail;
17462 temp3 = true;
17463 }
17464 {
17465 PyThreadState* __tstate = wxPyBeginAllowThreads();
17466 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17467
17468 wxPyEndAllowThreads(__tstate);
17469 if (PyErr_Occurred()) SWIG_fail;
17470 }
17471 {
17472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17473 }
17474 {
17475 if (temp2)
17476 delete arg2;
17477 }
17478 {
17479 if (temp3)
17480 delete arg3;
17481 }
17482 return resultobj;
17483 fail:
17484 {
17485 if (temp2)
17486 delete arg2;
17487 }
17488 {
17489 if (temp3)
17490 delete arg3;
17491 }
17492 return NULL;
17493 }
17494
17495
17496 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj;
17498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17499 wxString *arg2 = 0 ;
17500 wxString *arg3 = 0 ;
17501 bool result;
17502 bool temp2 = false ;
17503 bool temp3 = false ;
17504 PyObject * obj0 = 0 ;
17505 PyObject * obj1 = 0 ;
17506 PyObject * obj2 = 0 ;
17507 char *kwnames[] = {
17508 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17509 };
17510
17511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17513 if (SWIG_arg_fail(1)) SWIG_fail;
17514 {
17515 arg2 = wxString_in_helper(obj1);
17516 if (arg2 == NULL) SWIG_fail;
17517 temp2 = true;
17518 }
17519 {
17520 arg3 = wxString_in_helper(obj2);
17521 if (arg3 == NULL) SWIG_fail;
17522 temp3 = true;
17523 }
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17527
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 {
17532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17533 }
17534 {
17535 if (temp2)
17536 delete arg2;
17537 }
17538 {
17539 if (temp3)
17540 delete arg3;
17541 }
17542 return resultobj;
17543 fail:
17544 {
17545 if (temp2)
17546 delete arg2;
17547 }
17548 {
17549 if (temp3)
17550 delete arg3;
17551 }
17552 return NULL;
17553 }
17554
17555
17556 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj;
17558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17559 wxString *arg2 = 0 ;
17560 bool arg3 = (bool) true ;
17561 bool result;
17562 bool temp2 = false ;
17563 PyObject * obj0 = 0 ;
17564 PyObject * obj1 = 0 ;
17565 PyObject * obj2 = 0 ;
17566 char *kwnames[] = {
17567 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17568 };
17569
17570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17572 if (SWIG_arg_fail(1)) SWIG_fail;
17573 {
17574 arg2 = wxString_in_helper(obj1);
17575 if (arg2 == NULL) SWIG_fail;
17576 temp2 = true;
17577 }
17578 if (obj2) {
17579 {
17580 arg3 = (bool)(SWIG_As_bool(obj2));
17581 if (SWIG_arg_fail(3)) SWIG_fail;
17582 }
17583 }
17584 {
17585 PyThreadState* __tstate = wxPyBeginAllowThreads();
17586 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17587
17588 wxPyEndAllowThreads(__tstate);
17589 if (PyErr_Occurred()) SWIG_fail;
17590 }
17591 {
17592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17593 }
17594 {
17595 if (temp2)
17596 delete arg2;
17597 }
17598 return resultobj;
17599 fail:
17600 {
17601 if (temp2)
17602 delete arg2;
17603 }
17604 return NULL;
17605 }
17606
17607
17608 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj;
17610 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17611 wxString *arg2 = 0 ;
17612 bool result;
17613 bool temp2 = false ;
17614 PyObject * obj0 = 0 ;
17615 PyObject * obj1 = 0 ;
17616 char *kwnames[] = {
17617 (char *) "self",(char *) "key", NULL
17618 };
17619
17620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17622 if (SWIG_arg_fail(1)) SWIG_fail;
17623 {
17624 arg2 = wxString_in_helper(obj1);
17625 if (arg2 == NULL) SWIG_fail;
17626 temp2 = true;
17627 }
17628 {
17629 PyThreadState* __tstate = wxPyBeginAllowThreads();
17630 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17631
17632 wxPyEndAllowThreads(__tstate);
17633 if (PyErr_Occurred()) SWIG_fail;
17634 }
17635 {
17636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17637 }
17638 {
17639 if (temp2)
17640 delete arg2;
17641 }
17642 return resultobj;
17643 fail:
17644 {
17645 if (temp2)
17646 delete arg2;
17647 }
17648 return NULL;
17649 }
17650
17651
17652 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17653 PyObject *resultobj;
17654 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17655 bool result;
17656 PyObject * obj0 = 0 ;
17657 char *kwnames[] = {
17658 (char *) "self", NULL
17659 };
17660
17661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17663 if (SWIG_arg_fail(1)) SWIG_fail;
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 result = (bool)(arg1)->DeleteAll();
17667
17668 wxPyEndAllowThreads(__tstate);
17669 if (PyErr_Occurred()) SWIG_fail;
17670 }
17671 {
17672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17673 }
17674 return resultobj;
17675 fail:
17676 return NULL;
17677 }
17678
17679
17680 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17681 PyObject *resultobj;
17682 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17683 bool arg2 = (bool) true ;
17684 PyObject * obj0 = 0 ;
17685 PyObject * obj1 = 0 ;
17686 char *kwnames[] = {
17687 (char *) "self",(char *) "doIt", NULL
17688 };
17689
17690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(1)) SWIG_fail;
17693 if (obj1) {
17694 {
17695 arg2 = (bool)(SWIG_As_bool(obj1));
17696 if (SWIG_arg_fail(2)) SWIG_fail;
17697 }
17698 }
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 (arg1)->SetExpandEnvVars(arg2);
17702
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 Py_INCREF(Py_None); resultobj = Py_None;
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17714 PyObject *resultobj;
17715 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17716 bool result;
17717 PyObject * obj0 = 0 ;
17718 char *kwnames[] = {
17719 (char *) "self", NULL
17720 };
17721
17722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17724 if (SWIG_arg_fail(1)) SWIG_fail;
17725 {
17726 PyThreadState* __tstate = wxPyBeginAllowThreads();
17727 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17728
17729 wxPyEndAllowThreads(__tstate);
17730 if (PyErr_Occurred()) SWIG_fail;
17731 }
17732 {
17733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17734 }
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj;
17743 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17744 bool arg2 = (bool) true ;
17745 PyObject * obj0 = 0 ;
17746 PyObject * obj1 = 0 ;
17747 char *kwnames[] = {
17748 (char *) "self",(char *) "doIt", NULL
17749 };
17750
17751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17753 if (SWIG_arg_fail(1)) SWIG_fail;
17754 if (obj1) {
17755 {
17756 arg2 = (bool)(SWIG_As_bool(obj1));
17757 if (SWIG_arg_fail(2)) SWIG_fail;
17758 }
17759 }
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 (arg1)->SetRecordDefaults(arg2);
17763
17764 wxPyEndAllowThreads(__tstate);
17765 if (PyErr_Occurred()) SWIG_fail;
17766 }
17767 Py_INCREF(Py_None); resultobj = Py_None;
17768 return resultobj;
17769 fail:
17770 return NULL;
17771 }
17772
17773
17774 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17775 PyObject *resultobj;
17776 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17777 bool result;
17778 PyObject * obj0 = 0 ;
17779 char *kwnames[] = {
17780 (char *) "self", NULL
17781 };
17782
17783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17785 if (SWIG_arg_fail(1)) SWIG_fail;
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17789
17790 wxPyEndAllowThreads(__tstate);
17791 if (PyErr_Occurred()) SWIG_fail;
17792 }
17793 {
17794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17795 }
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj;
17804 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17805 wxString *arg2 = 0 ;
17806 wxString result;
17807 bool temp2 = false ;
17808 PyObject * obj0 = 0 ;
17809 PyObject * obj1 = 0 ;
17810 char *kwnames[] = {
17811 (char *) "self",(char *) "str", NULL
17812 };
17813
17814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17816 if (SWIG_arg_fail(1)) SWIG_fail;
17817 {
17818 arg2 = wxString_in_helper(obj1);
17819 if (arg2 == NULL) SWIG_fail;
17820 temp2 = true;
17821 }
17822 {
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17825
17826 wxPyEndAllowThreads(__tstate);
17827 if (PyErr_Occurred()) SWIG_fail;
17828 }
17829 {
17830 #if wxUSE_UNICODE
17831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17832 #else
17833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17834 #endif
17835 }
17836 {
17837 if (temp2)
17838 delete arg2;
17839 }
17840 return resultobj;
17841 fail:
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 return NULL;
17847 }
17848
17849
17850 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17851 PyObject *resultobj;
17852 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17853 wxString result;
17854 PyObject * obj0 = 0 ;
17855 char *kwnames[] = {
17856 (char *) "self", NULL
17857 };
17858
17859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
17860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17861 if (SWIG_arg_fail(1)) SWIG_fail;
17862 {
17863 PyThreadState* __tstate = wxPyBeginAllowThreads();
17864 result = ((wxConfigBase const *)arg1)->GetAppName();
17865
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 #if wxUSE_UNICODE
17871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17872 #else
17873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17874 #endif
17875 }
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17883 PyObject *resultobj;
17884 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17885 wxString result;
17886 PyObject * obj0 = 0 ;
17887 char *kwnames[] = {
17888 (char *) "self", NULL
17889 };
17890
17891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17893 if (SWIG_arg_fail(1)) SWIG_fail;
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 result = ((wxConfigBase const *)arg1)->GetVendorName();
17897
17898 wxPyEndAllowThreads(__tstate);
17899 if (PyErr_Occurred()) SWIG_fail;
17900 }
17901 {
17902 #if wxUSE_UNICODE
17903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17904 #else
17905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17906 #endif
17907 }
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj;
17916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17917 wxString *arg2 = 0 ;
17918 bool temp2 = false ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 char *kwnames[] = {
17922 (char *) "self",(char *) "appName", NULL
17923 };
17924
17925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17927 if (SWIG_arg_fail(1)) SWIG_fail;
17928 {
17929 arg2 = wxString_in_helper(obj1);
17930 if (arg2 == NULL) SWIG_fail;
17931 temp2 = true;
17932 }
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 (arg1)->SetAppName((wxString const &)*arg2);
17936
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 Py_INCREF(Py_None); resultobj = Py_None;
17941 {
17942 if (temp2)
17943 delete arg2;
17944 }
17945 return resultobj;
17946 fail:
17947 {
17948 if (temp2)
17949 delete arg2;
17950 }
17951 return NULL;
17952 }
17953
17954
17955 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj;
17957 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17958 wxString *arg2 = 0 ;
17959 bool temp2 = false ;
17960 PyObject * obj0 = 0 ;
17961 PyObject * obj1 = 0 ;
17962 char *kwnames[] = {
17963 (char *) "self",(char *) "vendorName", NULL
17964 };
17965
17966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17968 if (SWIG_arg_fail(1)) SWIG_fail;
17969 {
17970 arg2 = wxString_in_helper(obj1);
17971 if (arg2 == NULL) SWIG_fail;
17972 temp2 = true;
17973 }
17974 {
17975 PyThreadState* __tstate = wxPyBeginAllowThreads();
17976 (arg1)->SetVendorName((wxString const &)*arg2);
17977
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 Py_INCREF(Py_None); resultobj = Py_None;
17982 {
17983 if (temp2)
17984 delete arg2;
17985 }
17986 return resultobj;
17987 fail:
17988 {
17989 if (temp2)
17990 delete arg2;
17991 }
17992 return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj;
17998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17999 long arg2 ;
18000 PyObject * obj0 = 0 ;
18001 PyObject * obj1 = 0 ;
18002 char *kwnames[] = {
18003 (char *) "self",(char *) "style", NULL
18004 };
18005
18006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18008 if (SWIG_arg_fail(1)) SWIG_fail;
18009 {
18010 arg2 = (long)(SWIG_As_long(obj1));
18011 if (SWIG_arg_fail(2)) SWIG_fail;
18012 }
18013 {
18014 PyThreadState* __tstate = wxPyBeginAllowThreads();
18015 (arg1)->SetStyle(arg2);
18016
18017 wxPyEndAllowThreads(__tstate);
18018 if (PyErr_Occurred()) SWIG_fail;
18019 }
18020 Py_INCREF(Py_None); resultobj = Py_None;
18021 return resultobj;
18022 fail:
18023 return NULL;
18024 }
18025
18026
18027 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18028 PyObject *resultobj;
18029 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18030 long result;
18031 PyObject * obj0 = 0 ;
18032 char *kwnames[] = {
18033 (char *) "self", NULL
18034 };
18035
18036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18038 if (SWIG_arg_fail(1)) SWIG_fail;
18039 {
18040 PyThreadState* __tstate = wxPyBeginAllowThreads();
18041 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18042
18043 wxPyEndAllowThreads(__tstate);
18044 if (PyErr_Occurred()) SWIG_fail;
18045 }
18046 {
18047 resultobj = SWIG_From_long((long)(result));
18048 }
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18056 PyObject *obj;
18057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18058 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18059 Py_INCREF(obj);
18060 return Py_BuildValue((char *)"");
18061 }
18062 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18063 PyObject *resultobj;
18064 wxString const &arg1_defvalue = wxPyEmptyString ;
18065 wxString *arg1 = (wxString *) &arg1_defvalue ;
18066 wxString const &arg2_defvalue = wxPyEmptyString ;
18067 wxString *arg2 = (wxString *) &arg2_defvalue ;
18068 wxString const &arg3_defvalue = wxPyEmptyString ;
18069 wxString *arg3 = (wxString *) &arg3_defvalue ;
18070 wxString const &arg4_defvalue = wxPyEmptyString ;
18071 wxString *arg4 = (wxString *) &arg4_defvalue ;
18072 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18073 wxConfig *result;
18074 bool temp1 = false ;
18075 bool temp2 = false ;
18076 bool temp3 = false ;
18077 bool temp4 = false ;
18078 PyObject * obj0 = 0 ;
18079 PyObject * obj1 = 0 ;
18080 PyObject * obj2 = 0 ;
18081 PyObject * obj3 = 0 ;
18082 PyObject * obj4 = 0 ;
18083 char *kwnames[] = {
18084 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18085 };
18086
18087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18088 if (obj0) {
18089 {
18090 arg1 = wxString_in_helper(obj0);
18091 if (arg1 == NULL) SWIG_fail;
18092 temp1 = true;
18093 }
18094 }
18095 if (obj1) {
18096 {
18097 arg2 = wxString_in_helper(obj1);
18098 if (arg2 == NULL) SWIG_fail;
18099 temp2 = true;
18100 }
18101 }
18102 if (obj2) {
18103 {
18104 arg3 = wxString_in_helper(obj2);
18105 if (arg3 == NULL) SWIG_fail;
18106 temp3 = true;
18107 }
18108 }
18109 if (obj3) {
18110 {
18111 arg4 = wxString_in_helper(obj3);
18112 if (arg4 == NULL) SWIG_fail;
18113 temp4 = true;
18114 }
18115 }
18116 if (obj4) {
18117 {
18118 arg5 = (long)(SWIG_As_long(obj4));
18119 if (SWIG_arg_fail(5)) SWIG_fail;
18120 }
18121 }
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18125
18126 wxPyEndAllowThreads(__tstate);
18127 if (PyErr_Occurred()) SWIG_fail;
18128 }
18129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18130 {
18131 if (temp1)
18132 delete arg1;
18133 }
18134 {
18135 if (temp2)
18136 delete arg2;
18137 }
18138 {
18139 if (temp3)
18140 delete arg3;
18141 }
18142 {
18143 if (temp4)
18144 delete arg4;
18145 }
18146 return resultobj;
18147 fail:
18148 {
18149 if (temp1)
18150 delete arg1;
18151 }
18152 {
18153 if (temp2)
18154 delete arg2;
18155 }
18156 {
18157 if (temp3)
18158 delete arg3;
18159 }
18160 {
18161 if (temp4)
18162 delete arg4;
18163 }
18164 return NULL;
18165 }
18166
18167
18168 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18169 PyObject *resultobj;
18170 wxConfig *arg1 = (wxConfig *) 0 ;
18171 PyObject * obj0 = 0 ;
18172 char *kwnames[] = {
18173 (char *) "self", NULL
18174 };
18175
18176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18178 if (SWIG_arg_fail(1)) SWIG_fail;
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 delete arg1;
18182
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 Py_INCREF(Py_None); resultobj = Py_None;
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18194 PyObject *obj;
18195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18196 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18197 Py_INCREF(obj);
18198 return Py_BuildValue((char *)"");
18199 }
18200 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18201 PyObject *resultobj;
18202 wxString const &arg1_defvalue = wxPyEmptyString ;
18203 wxString *arg1 = (wxString *) &arg1_defvalue ;
18204 wxString const &arg2_defvalue = wxPyEmptyString ;
18205 wxString *arg2 = (wxString *) &arg2_defvalue ;
18206 wxString const &arg3_defvalue = wxPyEmptyString ;
18207 wxString *arg3 = (wxString *) &arg3_defvalue ;
18208 wxString const &arg4_defvalue = wxPyEmptyString ;
18209 wxString *arg4 = (wxString *) &arg4_defvalue ;
18210 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18211 wxFileConfig *result;
18212 bool temp1 = false ;
18213 bool temp2 = false ;
18214 bool temp3 = false ;
18215 bool temp4 = false ;
18216 PyObject * obj0 = 0 ;
18217 PyObject * obj1 = 0 ;
18218 PyObject * obj2 = 0 ;
18219 PyObject * obj3 = 0 ;
18220 PyObject * obj4 = 0 ;
18221 char *kwnames[] = {
18222 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18223 };
18224
18225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18226 if (obj0) {
18227 {
18228 arg1 = wxString_in_helper(obj0);
18229 if (arg1 == NULL) SWIG_fail;
18230 temp1 = true;
18231 }
18232 }
18233 if (obj1) {
18234 {
18235 arg2 = wxString_in_helper(obj1);
18236 if (arg2 == NULL) SWIG_fail;
18237 temp2 = true;
18238 }
18239 }
18240 if (obj2) {
18241 {
18242 arg3 = wxString_in_helper(obj2);
18243 if (arg3 == NULL) SWIG_fail;
18244 temp3 = true;
18245 }
18246 }
18247 if (obj3) {
18248 {
18249 arg4 = wxString_in_helper(obj3);
18250 if (arg4 == NULL) SWIG_fail;
18251 temp4 = true;
18252 }
18253 }
18254 if (obj4) {
18255 {
18256 arg5 = (long)(SWIG_As_long(obj4));
18257 if (SWIG_arg_fail(5)) SWIG_fail;
18258 }
18259 }
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18263
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18268 {
18269 if (temp1)
18270 delete arg1;
18271 }
18272 {
18273 if (temp2)
18274 delete arg2;
18275 }
18276 {
18277 if (temp3)
18278 delete arg3;
18279 }
18280 {
18281 if (temp4)
18282 delete arg4;
18283 }
18284 return resultobj;
18285 fail:
18286 {
18287 if (temp1)
18288 delete arg1;
18289 }
18290 {
18291 if (temp2)
18292 delete arg2;
18293 }
18294 {
18295 if (temp3)
18296 delete arg3;
18297 }
18298 {
18299 if (temp4)
18300 delete arg4;
18301 }
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj;
18308 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18309 PyObject * obj0 = 0 ;
18310 char *kwnames[] = {
18311 (char *) "self", NULL
18312 };
18313
18314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18316 if (SWIG_arg_fail(1)) SWIG_fail;
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 delete arg1;
18320
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 Py_INCREF(Py_None); resultobj = Py_None;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18332 PyObject *obj;
18333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18334 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18335 Py_INCREF(obj);
18336 return Py_BuildValue((char *)"");
18337 }
18338 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18339 PyObject *resultobj;
18340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18341 wxString *arg2 = 0 ;
18342 wxConfigPathChanger *result;
18343 bool temp2 = false ;
18344 PyObject * obj0 = 0 ;
18345 PyObject * obj1 = 0 ;
18346 char *kwnames[] = {
18347 (char *) "config",(char *) "entry", NULL
18348 };
18349
18350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18352 if (SWIG_arg_fail(1)) SWIG_fail;
18353 {
18354 arg2 = wxString_in_helper(obj1);
18355 if (arg2 == NULL) SWIG_fail;
18356 temp2 = true;
18357 }
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18361
18362 wxPyEndAllowThreads(__tstate);
18363 if (PyErr_Occurred()) SWIG_fail;
18364 }
18365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18366 {
18367 if (temp2)
18368 delete arg2;
18369 }
18370 return resultobj;
18371 fail:
18372 {
18373 if (temp2)
18374 delete arg2;
18375 }
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj;
18382 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18383 PyObject * obj0 = 0 ;
18384 char *kwnames[] = {
18385 (char *) "self", NULL
18386 };
18387
18388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18390 if (SWIG_arg_fail(1)) SWIG_fail;
18391 {
18392 PyThreadState* __tstate = wxPyBeginAllowThreads();
18393 delete arg1;
18394
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 Py_INCREF(Py_None); resultobj = Py_None;
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj;
18407 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18408 wxString *result;
18409 PyObject * obj0 = 0 ;
18410 char *kwnames[] = {
18411 (char *) "self", NULL
18412 };
18413
18414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18416 if (SWIG_arg_fail(1)) SWIG_fail;
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 {
18420 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18421 result = (wxString *) &_result_ref;
18422 }
18423
18424 wxPyEndAllowThreads(__tstate);
18425 if (PyErr_Occurred()) SWIG_fail;
18426 }
18427 {
18428 #if wxUSE_UNICODE
18429 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18430 #else
18431 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18432 #endif
18433 }
18434 return resultobj;
18435 fail:
18436 return NULL;
18437 }
18438
18439
18440 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18441 PyObject *obj;
18442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18443 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18444 Py_INCREF(obj);
18445 return Py_BuildValue((char *)"");
18446 }
18447 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18448 PyObject *resultobj;
18449 wxString *arg1 = 0 ;
18450 wxString result;
18451 bool temp1 = false ;
18452 PyObject * obj0 = 0 ;
18453 char *kwnames[] = {
18454 (char *) "sz", NULL
18455 };
18456
18457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18458 {
18459 arg1 = wxString_in_helper(obj0);
18460 if (arg1 == NULL) SWIG_fail;
18461 temp1 = true;
18462 }
18463 {
18464 PyThreadState* __tstate = wxPyBeginAllowThreads();
18465 result = wxExpandEnvVars((wxString const &)*arg1);
18466
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 {
18471 #if wxUSE_UNICODE
18472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18473 #else
18474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18475 #endif
18476 }
18477 {
18478 if (temp1)
18479 delete arg1;
18480 }
18481 return resultobj;
18482 fail:
18483 {
18484 if (temp1)
18485 delete arg1;
18486 }
18487 return NULL;
18488 }
18489
18490
18491 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18492 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18493 return 1;
18494 }
18495
18496
18497 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18498 PyObject *pyobj;
18499
18500 {
18501 #if wxUSE_UNICODE
18502 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18503 #else
18504 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18505 #endif
18506 }
18507 return pyobj;
18508 }
18509
18510
18511 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18512 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18513 return 1;
18514 }
18515
18516
18517 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18518 PyObject *pyobj;
18519
18520 {
18521 #if wxUSE_UNICODE
18522 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18523 #else
18524 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18525 #endif
18526 }
18527 return pyobj;
18528 }
18529
18530
18531 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj;
18533 wxDateTime::Country arg1 ;
18534 PyObject * obj0 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "country", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18540 {
18541 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18542 if (SWIG_arg_fail(1)) SWIG_fail;
18543 }
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18547
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 Py_INCREF(Py_None); resultobj = Py_None;
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxDateTime::Country result;
18561 char *kwnames[] = {
18562 NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (wxDateTime::Country)wxDateTime::GetCountry();
18569
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 resultobj = SWIG_From_int((result));
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj;
18582 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18583 bool result;
18584 PyObject * obj0 = 0 ;
18585 char *kwnames[] = {
18586 (char *) "country", NULL
18587 };
18588
18589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18590 if (obj0) {
18591 {
18592 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18593 if (SWIG_arg_fail(1)) SWIG_fail;
18594 }
18595 }
18596 {
18597 PyThreadState* __tstate = wxPyBeginAllowThreads();
18598 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18599
18600 wxPyEndAllowThreads(__tstate);
18601 if (PyErr_Occurred()) SWIG_fail;
18602 }
18603 {
18604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18605 }
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18613 PyObject *resultobj;
18614 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18615 int result;
18616 PyObject * obj0 = 0 ;
18617 char *kwnames[] = {
18618 (char *) "cal", NULL
18619 };
18620
18621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18622 if (obj0) {
18623 {
18624 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 }
18627 }
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18631
18632 wxPyEndAllowThreads(__tstate);
18633 if (PyErr_Occurred()) SWIG_fail;
18634 }
18635 {
18636 resultobj = SWIG_From_int((int)(result));
18637 }
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18645 PyObject *resultobj;
18646 int arg1 ;
18647 int result;
18648 PyObject * obj0 = 0 ;
18649 char *kwnames[] = {
18650 (char *) "year", NULL
18651 };
18652
18653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18654 {
18655 arg1 = (int)(SWIG_As_int(obj0));
18656 if (SWIG_arg_fail(1)) SWIG_fail;
18657 }
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)wxDateTime::ConvertYearToBC(arg1);
18661
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 {
18666 resultobj = SWIG_From_int((int)(result));
18667 }
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj;
18676 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18677 wxDateTime::Month result;
18678 PyObject * obj0 = 0 ;
18679 char *kwnames[] = {
18680 (char *) "cal", NULL
18681 };
18682
18683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18684 if (obj0) {
18685 {
18686 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18687 if (SWIG_arg_fail(1)) SWIG_fail;
18688 }
18689 }
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18693
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 resultobj = SWIG_From_int((result));
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj;
18706 int arg1 = (int) wxDateTime::Inv_Year ;
18707 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18708 bool result;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 char *kwnames[] = {
18712 (char *) "year",(char *) "cal", NULL
18713 };
18714
18715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18716 if (obj0) {
18717 {
18718 arg1 = (int)(SWIG_As_int(obj0));
18719 if (SWIG_arg_fail(1)) SWIG_fail;
18720 }
18721 }
18722 if (obj1) {
18723 {
18724 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18725 if (SWIG_arg_fail(2)) SWIG_fail;
18726 }
18727 }
18728 {
18729 PyThreadState* __tstate = wxPyBeginAllowThreads();
18730 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18731
18732 wxPyEndAllowThreads(__tstate);
18733 if (PyErr_Occurred()) SWIG_fail;
18734 }
18735 {
18736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18737 }
18738 return resultobj;
18739 fail:
18740 return NULL;
18741 }
18742
18743
18744 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18745 PyObject *resultobj;
18746 int arg1 = (int) wxDateTime::Inv_Year ;
18747 int result;
18748 PyObject * obj0 = 0 ;
18749 char *kwnames[] = {
18750 (char *) "year", NULL
18751 };
18752
18753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18754 if (obj0) {
18755 {
18756 arg1 = (int)(SWIG_As_int(obj0));
18757 if (SWIG_arg_fail(1)) SWIG_fail;
18758 }
18759 }
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 result = (int)wxDateTime::GetCentury(arg1);
18763
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 {
18768 resultobj = SWIG_From_int((int)(result));
18769 }
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj;
18778 int arg1 ;
18779 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18780 int result;
18781 PyObject * obj0 = 0 ;
18782 PyObject * obj1 = 0 ;
18783 char *kwnames[] = {
18784 (char *) "year",(char *) "cal", NULL
18785 };
18786
18787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18788 {
18789 arg1 = (int)(SWIG_As_int(obj0));
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 }
18792 if (obj1) {
18793 {
18794 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18795 if (SWIG_arg_fail(2)) SWIG_fail;
18796 }
18797 }
18798 {
18799 PyThreadState* __tstate = wxPyBeginAllowThreads();
18800 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18801
18802 wxPyEndAllowThreads(__tstate);
18803 if (PyErr_Occurred()) SWIG_fail;
18804 }
18805 {
18806 resultobj = SWIG_From_int((int)(result));
18807 }
18808 return resultobj;
18809 fail:
18810 return NULL;
18811 }
18812
18813
18814 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj;
18816 wxDateTime::Month arg1 ;
18817 int arg2 = (int) wxDateTime::Inv_Year ;
18818 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18819 int result;
18820 PyObject * obj0 = 0 ;
18821 PyObject * obj1 = 0 ;
18822 PyObject * obj2 = 0 ;
18823 char *kwnames[] = {
18824 (char *) "month",(char *) "year",(char *) "cal", NULL
18825 };
18826
18827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18828 {
18829 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18830 if (SWIG_arg_fail(1)) SWIG_fail;
18831 }
18832 if (obj1) {
18833 {
18834 arg2 = (int)(SWIG_As_int(obj1));
18835 if (SWIG_arg_fail(2)) SWIG_fail;
18836 }
18837 }
18838 if (obj2) {
18839 {
18840 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18841 if (SWIG_arg_fail(3)) SWIG_fail;
18842 }
18843 }
18844 {
18845 PyThreadState* __tstate = wxPyBeginAllowThreads();
18846 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18847
18848 wxPyEndAllowThreads(__tstate);
18849 if (PyErr_Occurred()) SWIG_fail;
18850 }
18851 {
18852 resultobj = SWIG_From_int((int)(result));
18853 }
18854 return resultobj;
18855 fail:
18856 return NULL;
18857 }
18858
18859
18860 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18861 PyObject *resultobj;
18862 wxDateTime::Month arg1 ;
18863 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18864 wxString result;
18865 PyObject * obj0 = 0 ;
18866 PyObject * obj1 = 0 ;
18867 char *kwnames[] = {
18868 (char *) "month",(char *) "flags", NULL
18869 };
18870
18871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18872 {
18873 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18874 if (SWIG_arg_fail(1)) SWIG_fail;
18875 }
18876 if (obj1) {
18877 {
18878 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18879 if (SWIG_arg_fail(2)) SWIG_fail;
18880 }
18881 }
18882 {
18883 PyThreadState* __tstate = wxPyBeginAllowThreads();
18884 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18885
18886 wxPyEndAllowThreads(__tstate);
18887 if (PyErr_Occurred()) SWIG_fail;
18888 }
18889 {
18890 #if wxUSE_UNICODE
18891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18892 #else
18893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18894 #endif
18895 }
18896 return resultobj;
18897 fail:
18898 return NULL;
18899 }
18900
18901
18902 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18903 PyObject *resultobj;
18904 wxDateTime::WeekDay arg1 ;
18905 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18906 wxString result;
18907 PyObject * obj0 = 0 ;
18908 PyObject * obj1 = 0 ;
18909 char *kwnames[] = {
18910 (char *) "weekday",(char *) "flags", NULL
18911 };
18912
18913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18914 {
18915 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18916 if (SWIG_arg_fail(1)) SWIG_fail;
18917 }
18918 if (obj1) {
18919 {
18920 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18921 if (SWIG_arg_fail(2)) SWIG_fail;
18922 }
18923 }
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18927
18928 wxPyEndAllowThreads(__tstate);
18929 if (PyErr_Occurred()) SWIG_fail;
18930 }
18931 {
18932 #if wxUSE_UNICODE
18933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18934 #else
18935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18936 #endif
18937 }
18938 return resultobj;
18939 fail:
18940 return NULL;
18941 }
18942
18943
18944 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj;
18946 wxString *arg1 = (wxString *) 0 ;
18947 wxString *arg2 = (wxString *) 0 ;
18948 bool temp1 = false ;
18949 bool temp2 = false ;
18950 PyObject * obj0 = 0 ;
18951 PyObject * obj1 = 0 ;
18952 char *kwnames[] = {
18953 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18954 };
18955
18956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18957 {
18958 arg1 = wxString_in_helper(obj0);
18959 if (arg1 == NULL) SWIG_fail;
18960 temp1 = true;
18961 }
18962 {
18963 arg2 = wxString_in_helper(obj1);
18964 if (arg2 == NULL) SWIG_fail;
18965 temp2 = true;
18966 }
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 wxDateTime::GetAmPmStrings(arg1,arg2);
18970
18971 wxPyEndAllowThreads(__tstate);
18972 if (PyErr_Occurred()) SWIG_fail;
18973 }
18974 Py_INCREF(Py_None); resultobj = Py_None;
18975 {
18976 if (temp1)
18977 delete arg1;
18978 }
18979 {
18980 if (temp2)
18981 delete arg2;
18982 }
18983 return resultobj;
18984 fail:
18985 {
18986 if (temp1)
18987 delete arg1;
18988 }
18989 {
18990 if (temp2)
18991 delete arg2;
18992 }
18993 return NULL;
18994 }
18995
18996
18997 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj;
18999 int arg1 = (int) wxDateTime::Inv_Year ;
19000 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19001 bool result;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char *kwnames[] = {
19005 (char *) "year",(char *) "country", NULL
19006 };
19007
19008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19009 if (obj0) {
19010 {
19011 arg1 = (int)(SWIG_As_int(obj0));
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 }
19014 }
19015 if (obj1) {
19016 {
19017 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19018 if (SWIG_arg_fail(2)) SWIG_fail;
19019 }
19020 }
19021 {
19022 PyThreadState* __tstate = wxPyBeginAllowThreads();
19023 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19024
19025 wxPyEndAllowThreads(__tstate);
19026 if (PyErr_Occurred()) SWIG_fail;
19027 }
19028 {
19029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19030 }
19031 return resultobj;
19032 fail:
19033 return NULL;
19034 }
19035
19036
19037 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19038 PyObject *resultobj;
19039 int arg1 = (int) wxDateTime::Inv_Year ;
19040 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19041 wxDateTime result;
19042 PyObject * obj0 = 0 ;
19043 PyObject * obj1 = 0 ;
19044 char *kwnames[] = {
19045 (char *) "year",(char *) "country", NULL
19046 };
19047
19048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19049 if (obj0) {
19050 {
19051 arg1 = (int)(SWIG_As_int(obj0));
19052 if (SWIG_arg_fail(1)) SWIG_fail;
19053 }
19054 }
19055 if (obj1) {
19056 {
19057 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19058 if (SWIG_arg_fail(2)) SWIG_fail;
19059 }
19060 }
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19064
19065 wxPyEndAllowThreads(__tstate);
19066 if (PyErr_Occurred()) SWIG_fail;
19067 }
19068 {
19069 wxDateTime * resultptr;
19070 resultptr = new wxDateTime((wxDateTime &)(result));
19071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19072 }
19073 return resultobj;
19074 fail:
19075 return NULL;
19076 }
19077
19078
19079 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19080 PyObject *resultobj;
19081 int arg1 = (int) wxDateTime::Inv_Year ;
19082 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19083 wxDateTime result;
19084 PyObject * obj0 = 0 ;
19085 PyObject * obj1 = 0 ;
19086 char *kwnames[] = {
19087 (char *) "year",(char *) "country", NULL
19088 };
19089
19090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19091 if (obj0) {
19092 {
19093 arg1 = (int)(SWIG_As_int(obj0));
19094 if (SWIG_arg_fail(1)) SWIG_fail;
19095 }
19096 }
19097 if (obj1) {
19098 {
19099 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19100 if (SWIG_arg_fail(2)) SWIG_fail;
19101 }
19102 }
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19106
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 {
19111 wxDateTime * resultptr;
19112 resultptr = new wxDateTime((wxDateTime &)(result));
19113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19114 }
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj;
19123 wxDateTime result;
19124 char *kwnames[] = {
19125 NULL
19126 };
19127
19128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19129 {
19130 PyThreadState* __tstate = wxPyBeginAllowThreads();
19131 result = wxDateTime::Now();
19132
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 {
19137 wxDateTime * resultptr;
19138 resultptr = new wxDateTime((wxDateTime &)(result));
19139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19140 }
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19148 PyObject *resultobj;
19149 wxDateTime result;
19150 char *kwnames[] = {
19151 NULL
19152 };
19153
19154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 result = wxDateTime::UNow();
19158
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 {
19163 wxDateTime * resultptr;
19164 resultptr = new wxDateTime((wxDateTime &)(result));
19165 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19166 }
19167 return resultobj;
19168 fail:
19169 return NULL;
19170 }
19171
19172
19173 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19174 PyObject *resultobj;
19175 wxDateTime result;
19176 char *kwnames[] = {
19177 NULL
19178 };
19179
19180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 result = wxDateTime::Today();
19184
19185 wxPyEndAllowThreads(__tstate);
19186 if (PyErr_Occurred()) SWIG_fail;
19187 }
19188 {
19189 wxDateTime * resultptr;
19190 resultptr = new wxDateTime((wxDateTime &)(result));
19191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19192 }
19193 return resultobj;
19194 fail:
19195 return NULL;
19196 }
19197
19198
19199 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19200 PyObject *resultobj;
19201 wxDateTime *result;
19202 char *kwnames[] = {
19203 NULL
19204 };
19205
19206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 result = (wxDateTime *)new wxDateTime();
19210
19211 wxPyEndAllowThreads(__tstate);
19212 if (PyErr_Occurred()) SWIG_fail;
19213 }
19214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj;
19223 time_t arg1 ;
19224 wxDateTime *result;
19225 PyObject * obj0 = 0 ;
19226 char *kwnames[] = {
19227 (char *) "timet", NULL
19228 };
19229
19230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19231 {
19232 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19233 if (SWIG_arg_fail(1)) SWIG_fail;
19234 }
19235 {
19236 PyThreadState* __tstate = wxPyBeginAllowThreads();
19237 result = (wxDateTime *)new wxDateTime(arg1);
19238
19239 wxPyEndAllowThreads(__tstate);
19240 if (PyErr_Occurred()) SWIG_fail;
19241 }
19242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj;
19251 double arg1 ;
19252 wxDateTime *result;
19253 PyObject * obj0 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "jdn", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19259 {
19260 arg1 = (double)(SWIG_As_double(obj0));
19261 if (SWIG_arg_fail(1)) SWIG_fail;
19262 }
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (wxDateTime *)new wxDateTime(arg1);
19266
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj;
19279 int arg1 ;
19280 int arg2 = (int) 0 ;
19281 int arg3 = (int) 0 ;
19282 int arg4 = (int) 0 ;
19283 wxDateTime *result;
19284 PyObject * obj0 = 0 ;
19285 PyObject * obj1 = 0 ;
19286 PyObject * obj2 = 0 ;
19287 PyObject * obj3 = 0 ;
19288 char *kwnames[] = {
19289 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19290 };
19291
19292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19293 {
19294 arg1 = (int)(SWIG_As_int(obj0));
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 }
19297 if (obj1) {
19298 {
19299 arg2 = (int)(SWIG_As_int(obj1));
19300 if (SWIG_arg_fail(2)) SWIG_fail;
19301 }
19302 }
19303 if (obj2) {
19304 {
19305 arg3 = (int)(SWIG_As_int(obj2));
19306 if (SWIG_arg_fail(3)) SWIG_fail;
19307 }
19308 }
19309 if (obj3) {
19310 {
19311 arg4 = (int)(SWIG_As_int(obj3));
19312 if (SWIG_arg_fail(4)) SWIG_fail;
19313 }
19314 }
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19318
19319 wxPyEndAllowThreads(__tstate);
19320 if (PyErr_Occurred()) SWIG_fail;
19321 }
19322 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19323 return resultobj;
19324 fail:
19325 return NULL;
19326 }
19327
19328
19329 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj;
19331 int arg1 ;
19332 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19333 int arg3 = (int) wxDateTime::Inv_Year ;
19334 int arg4 = (int) 0 ;
19335 int arg5 = (int) 0 ;
19336 int arg6 = (int) 0 ;
19337 int arg7 = (int) 0 ;
19338 wxDateTime *result;
19339 PyObject * obj0 = 0 ;
19340 PyObject * obj1 = 0 ;
19341 PyObject * obj2 = 0 ;
19342 PyObject * obj3 = 0 ;
19343 PyObject * obj4 = 0 ;
19344 PyObject * obj5 = 0 ;
19345 PyObject * obj6 = 0 ;
19346 char *kwnames[] = {
19347 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19348 };
19349
19350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19351 {
19352 arg1 = (int)(SWIG_As_int(obj0));
19353 if (SWIG_arg_fail(1)) SWIG_fail;
19354 }
19355 if (obj1) {
19356 {
19357 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19358 if (SWIG_arg_fail(2)) SWIG_fail;
19359 }
19360 }
19361 if (obj2) {
19362 {
19363 arg3 = (int)(SWIG_As_int(obj2));
19364 if (SWIG_arg_fail(3)) SWIG_fail;
19365 }
19366 }
19367 if (obj3) {
19368 {
19369 arg4 = (int)(SWIG_As_int(obj3));
19370 if (SWIG_arg_fail(4)) SWIG_fail;
19371 }
19372 }
19373 if (obj4) {
19374 {
19375 arg5 = (int)(SWIG_As_int(obj4));
19376 if (SWIG_arg_fail(5)) SWIG_fail;
19377 }
19378 }
19379 if (obj5) {
19380 {
19381 arg6 = (int)(SWIG_As_int(obj5));
19382 if (SWIG_arg_fail(6)) SWIG_fail;
19383 }
19384 }
19385 if (obj6) {
19386 {
19387 arg7 = (int)(SWIG_As_int(obj6));
19388 if (SWIG_arg_fail(7)) SWIG_fail;
19389 }
19390 }
19391 {
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19394
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19399 return resultobj;
19400 fail:
19401 return NULL;
19402 }
19403
19404
19405 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19406 PyObject *resultobj;
19407 wxDateTime *arg1 = (wxDateTime *) 0 ;
19408 PyObject * obj0 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "self", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(1)) SWIG_fail;
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 delete arg1;
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 Py_INCREF(Py_None); resultobj = Py_None;
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj;
19432 wxDateTime *arg1 = (wxDateTime *) 0 ;
19433 wxDateTime *result;
19434 PyObject * obj0 = 0 ;
19435 char *kwnames[] = {
19436 (char *) "self", NULL
19437 };
19438
19439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19441 if (SWIG_arg_fail(1)) SWIG_fail;
19442 {
19443 PyThreadState* __tstate = wxPyBeginAllowThreads();
19444 {
19445 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19446 result = (wxDateTime *) &_result_ref;
19447 }
19448
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19453 return resultobj;
19454 fail:
19455 return NULL;
19456 }
19457
19458
19459 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19460 PyObject *resultobj;
19461 wxDateTime *arg1 = (wxDateTime *) 0 ;
19462 time_t arg2 ;
19463 wxDateTime *result;
19464 PyObject * obj0 = 0 ;
19465 PyObject * obj1 = 0 ;
19466 char *kwnames[] = {
19467 (char *) "self",(char *) "timet", NULL
19468 };
19469
19470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19472 if (SWIG_arg_fail(1)) SWIG_fail;
19473 {
19474 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19475 if (SWIG_arg_fail(2)) SWIG_fail;
19476 }
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 {
19480 wxDateTime &_result_ref = (arg1)->Set(arg2);
19481 result = (wxDateTime *) &_result_ref;
19482 }
19483
19484 wxPyEndAllowThreads(__tstate);
19485 if (PyErr_Occurred()) SWIG_fail;
19486 }
19487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19488 return resultobj;
19489 fail:
19490 return NULL;
19491 }
19492
19493
19494 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19495 PyObject *resultobj;
19496 wxDateTime *arg1 = (wxDateTime *) 0 ;
19497 double arg2 ;
19498 wxDateTime *result;
19499 PyObject * obj0 = 0 ;
19500 PyObject * obj1 = 0 ;
19501 char *kwnames[] = {
19502 (char *) "self",(char *) "jdn", NULL
19503 };
19504
19505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19507 if (SWIG_arg_fail(1)) SWIG_fail;
19508 {
19509 arg2 = (double)(SWIG_As_double(obj1));
19510 if (SWIG_arg_fail(2)) SWIG_fail;
19511 }
19512 {
19513 PyThreadState* __tstate = wxPyBeginAllowThreads();
19514 {
19515 wxDateTime &_result_ref = (arg1)->Set(arg2);
19516 result = (wxDateTime *) &_result_ref;
19517 }
19518
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj;
19531 wxDateTime *arg1 = (wxDateTime *) 0 ;
19532 int arg2 ;
19533 int arg3 = (int) 0 ;
19534 int arg4 = (int) 0 ;
19535 int arg5 = (int) 0 ;
19536 wxDateTime *result;
19537 PyObject * obj0 = 0 ;
19538 PyObject * obj1 = 0 ;
19539 PyObject * obj2 = 0 ;
19540 PyObject * obj3 = 0 ;
19541 PyObject * obj4 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19548 if (SWIG_arg_fail(1)) SWIG_fail;
19549 {
19550 arg2 = (int)(SWIG_As_int(obj1));
19551 if (SWIG_arg_fail(2)) SWIG_fail;
19552 }
19553 if (obj2) {
19554 {
19555 arg3 = (int)(SWIG_As_int(obj2));
19556 if (SWIG_arg_fail(3)) SWIG_fail;
19557 }
19558 }
19559 if (obj3) {
19560 {
19561 arg4 = (int)(SWIG_As_int(obj3));
19562 if (SWIG_arg_fail(4)) SWIG_fail;
19563 }
19564 }
19565 if (obj4) {
19566 {
19567 arg5 = (int)(SWIG_As_int(obj4));
19568 if (SWIG_arg_fail(5)) SWIG_fail;
19569 }
19570 }
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 {
19574 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19575 result = (wxDateTime *) &_result_ref;
19576 }
19577
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj;
19590 wxDateTime *arg1 = (wxDateTime *) 0 ;
19591 int arg2 ;
19592 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19593 int arg4 = (int) wxDateTime::Inv_Year ;
19594 int arg5 = (int) 0 ;
19595 int arg6 = (int) 0 ;
19596 int arg7 = (int) 0 ;
19597 int arg8 = (int) 0 ;
19598 wxDateTime *result;
19599 PyObject * obj0 = 0 ;
19600 PyObject * obj1 = 0 ;
19601 PyObject * obj2 = 0 ;
19602 PyObject * obj3 = 0 ;
19603 PyObject * obj4 = 0 ;
19604 PyObject * obj5 = 0 ;
19605 PyObject * obj6 = 0 ;
19606 PyObject * obj7 = 0 ;
19607 char *kwnames[] = {
19608 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19609 };
19610
19611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19613 if (SWIG_arg_fail(1)) SWIG_fail;
19614 {
19615 arg2 = (int)(SWIG_As_int(obj1));
19616 if (SWIG_arg_fail(2)) SWIG_fail;
19617 }
19618 if (obj2) {
19619 {
19620 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19621 if (SWIG_arg_fail(3)) SWIG_fail;
19622 }
19623 }
19624 if (obj3) {
19625 {
19626 arg4 = (int)(SWIG_As_int(obj3));
19627 if (SWIG_arg_fail(4)) SWIG_fail;
19628 }
19629 }
19630 if (obj4) {
19631 {
19632 arg5 = (int)(SWIG_As_int(obj4));
19633 if (SWIG_arg_fail(5)) SWIG_fail;
19634 }
19635 }
19636 if (obj5) {
19637 {
19638 arg6 = (int)(SWIG_As_int(obj5));
19639 if (SWIG_arg_fail(6)) SWIG_fail;
19640 }
19641 }
19642 if (obj6) {
19643 {
19644 arg7 = (int)(SWIG_As_int(obj6));
19645 if (SWIG_arg_fail(7)) SWIG_fail;
19646 }
19647 }
19648 if (obj7) {
19649 {
19650 arg8 = (int)(SWIG_As_int(obj7));
19651 if (SWIG_arg_fail(8)) SWIG_fail;
19652 }
19653 }
19654 {
19655 PyThreadState* __tstate = wxPyBeginAllowThreads();
19656 {
19657 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19658 result = (wxDateTime *) &_result_ref;
19659 }
19660
19661 wxPyEndAllowThreads(__tstate);
19662 if (PyErr_Occurred()) SWIG_fail;
19663 }
19664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19665 return resultobj;
19666 fail:
19667 return NULL;
19668 }
19669
19670
19671 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj;
19673 wxDateTime *arg1 = (wxDateTime *) 0 ;
19674 wxDateTime *result;
19675 PyObject * obj0 = 0 ;
19676 char *kwnames[] = {
19677 (char *) "self", NULL
19678 };
19679
19680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19682 if (SWIG_arg_fail(1)) SWIG_fail;
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 {
19686 wxDateTime &_result_ref = (arg1)->ResetTime();
19687 result = (wxDateTime *) &_result_ref;
19688 }
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj;
19702 wxDateTime *arg1 = (wxDateTime *) 0 ;
19703 int arg2 ;
19704 wxDateTime *result;
19705 PyObject * obj0 = 0 ;
19706 PyObject * obj1 = 0 ;
19707 char *kwnames[] = {
19708 (char *) "self",(char *) "year", NULL
19709 };
19710
19711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19713 if (SWIG_arg_fail(1)) SWIG_fail;
19714 {
19715 arg2 = (int)(SWIG_As_int(obj1));
19716 if (SWIG_arg_fail(2)) SWIG_fail;
19717 }
19718 {
19719 PyThreadState* __tstate = wxPyBeginAllowThreads();
19720 {
19721 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19722 result = (wxDateTime *) &_result_ref;
19723 }
19724
19725 wxPyEndAllowThreads(__tstate);
19726 if (PyErr_Occurred()) SWIG_fail;
19727 }
19728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19729 return resultobj;
19730 fail:
19731 return NULL;
19732 }
19733
19734
19735 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19736 PyObject *resultobj;
19737 wxDateTime *arg1 = (wxDateTime *) 0 ;
19738 wxDateTime::Month arg2 ;
19739 wxDateTime *result;
19740 PyObject * obj0 = 0 ;
19741 PyObject * obj1 = 0 ;
19742 char *kwnames[] = {
19743 (char *) "self",(char *) "month", NULL
19744 };
19745
19746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19748 if (SWIG_arg_fail(1)) SWIG_fail;
19749 {
19750 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19751 if (SWIG_arg_fail(2)) SWIG_fail;
19752 }
19753 {
19754 PyThreadState* __tstate = wxPyBeginAllowThreads();
19755 {
19756 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19757 result = (wxDateTime *) &_result_ref;
19758 }
19759
19760 wxPyEndAllowThreads(__tstate);
19761 if (PyErr_Occurred()) SWIG_fail;
19762 }
19763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19764 return resultobj;
19765 fail:
19766 return NULL;
19767 }
19768
19769
19770 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19771 PyObject *resultobj;
19772 wxDateTime *arg1 = (wxDateTime *) 0 ;
19773 int arg2 ;
19774 wxDateTime *result;
19775 PyObject * obj0 = 0 ;
19776 PyObject * obj1 = 0 ;
19777 char *kwnames[] = {
19778 (char *) "self",(char *) "day", NULL
19779 };
19780
19781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19783 if (SWIG_arg_fail(1)) SWIG_fail;
19784 {
19785 arg2 = (int)(SWIG_As_int(obj1));
19786 if (SWIG_arg_fail(2)) SWIG_fail;
19787 }
19788 {
19789 PyThreadState* __tstate = wxPyBeginAllowThreads();
19790 {
19791 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19792 result = (wxDateTime *) &_result_ref;
19793 }
19794
19795 wxPyEndAllowThreads(__tstate);
19796 if (PyErr_Occurred()) SWIG_fail;
19797 }
19798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19799 return resultobj;
19800 fail:
19801 return NULL;
19802 }
19803
19804
19805 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj;
19807 wxDateTime *arg1 = (wxDateTime *) 0 ;
19808 int arg2 ;
19809 wxDateTime *result;
19810 PyObject * obj0 = 0 ;
19811 PyObject * obj1 = 0 ;
19812 char *kwnames[] = {
19813 (char *) "self",(char *) "hour", NULL
19814 };
19815
19816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19818 if (SWIG_arg_fail(1)) SWIG_fail;
19819 {
19820 arg2 = (int)(SWIG_As_int(obj1));
19821 if (SWIG_arg_fail(2)) SWIG_fail;
19822 }
19823 {
19824 PyThreadState* __tstate = wxPyBeginAllowThreads();
19825 {
19826 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19827 result = (wxDateTime *) &_result_ref;
19828 }
19829
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19834 return resultobj;
19835 fail:
19836 return NULL;
19837 }
19838
19839
19840 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19841 PyObject *resultobj;
19842 wxDateTime *arg1 = (wxDateTime *) 0 ;
19843 int arg2 ;
19844 wxDateTime *result;
19845 PyObject * obj0 = 0 ;
19846 PyObject * obj1 = 0 ;
19847 char *kwnames[] = {
19848 (char *) "self",(char *) "minute", NULL
19849 };
19850
19851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19853 if (SWIG_arg_fail(1)) SWIG_fail;
19854 {
19855 arg2 = (int)(SWIG_As_int(obj1));
19856 if (SWIG_arg_fail(2)) SWIG_fail;
19857 }
19858 {
19859 PyThreadState* __tstate = wxPyBeginAllowThreads();
19860 {
19861 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19862 result = (wxDateTime *) &_result_ref;
19863 }
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19869 return resultobj;
19870 fail:
19871 return NULL;
19872 }
19873
19874
19875 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19876 PyObject *resultobj;
19877 wxDateTime *arg1 = (wxDateTime *) 0 ;
19878 int arg2 ;
19879 wxDateTime *result;
19880 PyObject * obj0 = 0 ;
19881 PyObject * obj1 = 0 ;
19882 char *kwnames[] = {
19883 (char *) "self",(char *) "second", NULL
19884 };
19885
19886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19888 if (SWIG_arg_fail(1)) SWIG_fail;
19889 {
19890 arg2 = (int)(SWIG_As_int(obj1));
19891 if (SWIG_arg_fail(2)) SWIG_fail;
19892 }
19893 {
19894 PyThreadState* __tstate = wxPyBeginAllowThreads();
19895 {
19896 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
19897 result = (wxDateTime *) &_result_ref;
19898 }
19899
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj;
19912 wxDateTime *arg1 = (wxDateTime *) 0 ;
19913 int arg2 ;
19914 wxDateTime *result;
19915 PyObject * obj0 = 0 ;
19916 PyObject * obj1 = 0 ;
19917 char *kwnames[] = {
19918 (char *) "self",(char *) "millisecond", NULL
19919 };
19920
19921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19923 if (SWIG_arg_fail(1)) SWIG_fail;
19924 {
19925 arg2 = (int)(SWIG_As_int(obj1));
19926 if (SWIG_arg_fail(2)) SWIG_fail;
19927 }
19928 {
19929 PyThreadState* __tstate = wxPyBeginAllowThreads();
19930 {
19931 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19932 result = (wxDateTime *) &_result_ref;
19933 }
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj;
19947 wxDateTime *arg1 = (wxDateTime *) 0 ;
19948 wxDateTime::WeekDay arg2 ;
19949 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19950 wxDateTime *result;
19951 PyObject * obj0 = 0 ;
19952 PyObject * obj1 = 0 ;
19953 PyObject * obj2 = 0 ;
19954 char *kwnames[] = {
19955 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19956 };
19957
19958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19960 if (SWIG_arg_fail(1)) SWIG_fail;
19961 {
19962 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19963 if (SWIG_arg_fail(2)) SWIG_fail;
19964 }
19965 if (obj2) {
19966 {
19967 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19968 if (SWIG_arg_fail(3)) SWIG_fail;
19969 }
19970 }
19971 {
19972 PyThreadState* __tstate = wxPyBeginAllowThreads();
19973 {
19974 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19975 result = (wxDateTime *) &_result_ref;
19976 }
19977
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19982 return resultobj;
19983 fail:
19984 return NULL;
19985 }
19986
19987
19988 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19989 PyObject *resultobj;
19990 wxDateTime *arg1 = (wxDateTime *) 0 ;
19991 wxDateTime::WeekDay arg2 ;
19992 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19993 wxDateTime result;
19994 PyObject * obj0 = 0 ;
19995 PyObject * obj1 = 0 ;
19996 PyObject * obj2 = 0 ;
19997 char *kwnames[] = {
19998 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19999 };
20000
20001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20003 if (SWIG_arg_fail(1)) SWIG_fail;
20004 {
20005 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20006 if (SWIG_arg_fail(2)) SWIG_fail;
20007 }
20008 if (obj2) {
20009 {
20010 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20011 if (SWIG_arg_fail(3)) SWIG_fail;
20012 }
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 {
20022 wxDateTime * resultptr;
20023 resultptr = new wxDateTime((wxDateTime &)(result));
20024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20025 }
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxDateTime *arg1 = (wxDateTime *) 0 ;
20035 wxDateTime::WeekDay arg2 ;
20036 wxDateTime *result;
20037 PyObject * obj0 = 0 ;
20038 PyObject * obj1 = 0 ;
20039 char *kwnames[] = {
20040 (char *) "self",(char *) "weekday", NULL
20041 };
20042
20043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20045 if (SWIG_arg_fail(1)) SWIG_fail;
20046 {
20047 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20048 if (SWIG_arg_fail(2)) SWIG_fail;
20049 }
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 {
20053 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20054 result = (wxDateTime *) &_result_ref;
20055 }
20056
20057 wxPyEndAllowThreads(__tstate);
20058 if (PyErr_Occurred()) SWIG_fail;
20059 }
20060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20061 return resultobj;
20062 fail:
20063 return NULL;
20064 }
20065
20066
20067 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20068 PyObject *resultobj;
20069 wxDateTime *arg1 = (wxDateTime *) 0 ;
20070 wxDateTime::WeekDay arg2 ;
20071 wxDateTime result;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 char *kwnames[] = {
20075 (char *) "self",(char *) "weekday", NULL
20076 };
20077
20078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20080 if (SWIG_arg_fail(1)) SWIG_fail;
20081 {
20082 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20083 if (SWIG_arg_fail(2)) SWIG_fail;
20084 }
20085 {
20086 PyThreadState* __tstate = wxPyBeginAllowThreads();
20087 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20088
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 {
20093 wxDateTime * resultptr;
20094 resultptr = new wxDateTime((wxDateTime &)(result));
20095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20096 }
20097 return resultobj;
20098 fail:
20099 return NULL;
20100 }
20101
20102
20103 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20104 PyObject *resultobj;
20105 wxDateTime *arg1 = (wxDateTime *) 0 ;
20106 wxDateTime::WeekDay arg2 ;
20107 wxDateTime *result;
20108 PyObject * obj0 = 0 ;
20109 PyObject * obj1 = 0 ;
20110 char *kwnames[] = {
20111 (char *) "self",(char *) "weekday", NULL
20112 };
20113
20114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20116 if (SWIG_arg_fail(1)) SWIG_fail;
20117 {
20118 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20119 if (SWIG_arg_fail(2)) SWIG_fail;
20120 }
20121 {
20122 PyThreadState* __tstate = wxPyBeginAllowThreads();
20123 {
20124 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20125 result = (wxDateTime *) &_result_ref;
20126 }
20127
20128 wxPyEndAllowThreads(__tstate);
20129 if (PyErr_Occurred()) SWIG_fail;
20130 }
20131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20132 return resultobj;
20133 fail:
20134 return NULL;
20135 }
20136
20137
20138 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20139 PyObject *resultobj;
20140 wxDateTime *arg1 = (wxDateTime *) 0 ;
20141 wxDateTime::WeekDay arg2 ;
20142 wxDateTime result;
20143 PyObject * obj0 = 0 ;
20144 PyObject * obj1 = 0 ;
20145 char *kwnames[] = {
20146 (char *) "self",(char *) "weekday", NULL
20147 };
20148
20149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20151 if (SWIG_arg_fail(1)) SWIG_fail;
20152 {
20153 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20154 if (SWIG_arg_fail(2)) SWIG_fail;
20155 }
20156 {
20157 PyThreadState* __tstate = wxPyBeginAllowThreads();
20158 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20159
20160 wxPyEndAllowThreads(__tstate);
20161 if (PyErr_Occurred()) SWIG_fail;
20162 }
20163 {
20164 wxDateTime * resultptr;
20165 resultptr = new wxDateTime((wxDateTime &)(result));
20166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20167 }
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20175 PyObject *resultobj;
20176 wxDateTime *arg1 = (wxDateTime *) 0 ;
20177 wxDateTime::WeekDay arg2 ;
20178 int arg3 = (int) 1 ;
20179 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20180 int arg5 = (int) wxDateTime::Inv_Year ;
20181 bool result;
20182 PyObject * obj0 = 0 ;
20183 PyObject * obj1 = 0 ;
20184 PyObject * obj2 = 0 ;
20185 PyObject * obj3 = 0 ;
20186 PyObject * obj4 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 {
20195 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20196 if (SWIG_arg_fail(2)) SWIG_fail;
20197 }
20198 if (obj2) {
20199 {
20200 arg3 = (int)(SWIG_As_int(obj2));
20201 if (SWIG_arg_fail(3)) SWIG_fail;
20202 }
20203 }
20204 if (obj3) {
20205 {
20206 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20207 if (SWIG_arg_fail(4)) SWIG_fail;
20208 }
20209 }
20210 if (obj4) {
20211 {
20212 arg5 = (int)(SWIG_As_int(obj4));
20213 if (SWIG_arg_fail(5)) SWIG_fail;
20214 }
20215 }
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 {
20224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20225 }
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj;
20234 wxDateTime *arg1 = (wxDateTime *) 0 ;
20235 wxDateTime::WeekDay arg2 ;
20236 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20237 int arg4 = (int) wxDateTime::Inv_Year ;
20238 bool result;
20239 PyObject * obj0 = 0 ;
20240 PyObject * obj1 = 0 ;
20241 PyObject * obj2 = 0 ;
20242 PyObject * obj3 = 0 ;
20243 char *kwnames[] = {
20244 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20245 };
20246
20247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20249 if (SWIG_arg_fail(1)) SWIG_fail;
20250 {
20251 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20252 if (SWIG_arg_fail(2)) SWIG_fail;
20253 }
20254 if (obj2) {
20255 {
20256 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20257 if (SWIG_arg_fail(3)) SWIG_fail;
20258 }
20259 }
20260 if (obj3) {
20261 {
20262 arg4 = (int)(SWIG_As_int(obj3));
20263 if (SWIG_arg_fail(4)) SWIG_fail;
20264 }
20265 }
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20269
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 {
20274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20275 }
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj;
20284 wxDateTime *arg1 = (wxDateTime *) 0 ;
20285 wxDateTime::WeekDay arg2 ;
20286 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20287 int arg4 = (int) wxDateTime::Inv_Year ;
20288 wxDateTime result;
20289 PyObject * obj0 = 0 ;
20290 PyObject * obj1 = 0 ;
20291 PyObject * obj2 = 0 ;
20292 PyObject * obj3 = 0 ;
20293 char *kwnames[] = {
20294 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20295 };
20296
20297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20299 if (SWIG_arg_fail(1)) SWIG_fail;
20300 {
20301 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20302 if (SWIG_arg_fail(2)) SWIG_fail;
20303 }
20304 if (obj2) {
20305 {
20306 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20307 if (SWIG_arg_fail(3)) SWIG_fail;
20308 }
20309 }
20310 if (obj3) {
20311 {
20312 arg4 = (int)(SWIG_As_int(obj3));
20313 if (SWIG_arg_fail(4)) SWIG_fail;
20314 }
20315 }
20316 {
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20319
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 {
20324 wxDateTime * resultptr;
20325 resultptr = new wxDateTime((wxDateTime &)(result));
20326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20327 }
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20335 PyObject *resultobj;
20336 wxDateTime *arg1 = (wxDateTime *) 0 ;
20337 int arg2 ;
20338 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20339 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20340 bool result;
20341 PyObject * obj0 = 0 ;
20342 PyObject * obj1 = 0 ;
20343 PyObject * obj2 = 0 ;
20344 PyObject * obj3 = 0 ;
20345 char *kwnames[] = {
20346 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20347 };
20348
20349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20351 if (SWIG_arg_fail(1)) SWIG_fail;
20352 {
20353 arg2 = (int)(SWIG_As_int(obj1));
20354 if (SWIG_arg_fail(2)) SWIG_fail;
20355 }
20356 if (obj2) {
20357 {
20358 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20359 if (SWIG_arg_fail(3)) SWIG_fail;
20360 }
20361 }
20362 if (obj3) {
20363 {
20364 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20365 if (SWIG_arg_fail(4)) SWIG_fail;
20366 }
20367 }
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20371
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj;
20386 wxDateTime *arg1 = (wxDateTime *) 0 ;
20387 int arg2 ;
20388 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20389 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20390 wxDateTime result;
20391 PyObject * obj0 = 0 ;
20392 PyObject * obj1 = 0 ;
20393 PyObject * obj2 = 0 ;
20394 PyObject * obj3 = 0 ;
20395 char *kwnames[] = {
20396 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20397 };
20398
20399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20401 if (SWIG_arg_fail(1)) SWIG_fail;
20402 {
20403 arg2 = (int)(SWIG_As_int(obj1));
20404 if (SWIG_arg_fail(2)) SWIG_fail;
20405 }
20406 if (obj2) {
20407 {
20408 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20409 if (SWIG_arg_fail(3)) SWIG_fail;
20410 }
20411 }
20412 if (obj3) {
20413 {
20414 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20415 if (SWIG_arg_fail(4)) SWIG_fail;
20416 }
20417 }
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20421
20422 wxPyEndAllowThreads(__tstate);
20423 if (PyErr_Occurred()) SWIG_fail;
20424 }
20425 {
20426 wxDateTime * resultptr;
20427 resultptr = new wxDateTime((wxDateTime &)(result));
20428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20429 }
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20437 PyObject *resultobj;
20438 int arg1 ;
20439 int arg2 ;
20440 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20441 wxDateTime result;
20442 PyObject * obj0 = 0 ;
20443 PyObject * obj1 = 0 ;
20444 PyObject * obj2 = 0 ;
20445 char *kwnames[] = {
20446 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20447 };
20448
20449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20450 {
20451 arg1 = (int)(SWIG_As_int(obj0));
20452 if (SWIG_arg_fail(1)) SWIG_fail;
20453 }
20454 {
20455 arg2 = (int)(SWIG_As_int(obj1));
20456 if (SWIG_arg_fail(2)) SWIG_fail;
20457 }
20458 if (obj2) {
20459 {
20460 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20461 if (SWIG_arg_fail(3)) SWIG_fail;
20462 }
20463 }
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20467
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 {
20472 wxDateTime * resultptr;
20473 resultptr = new wxDateTime((wxDateTime &)(result));
20474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20475 }
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20483 PyObject *resultobj;
20484 wxDateTime *arg1 = (wxDateTime *) 0 ;
20485 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20486 int arg3 = (int) wxDateTime::Inv_Year ;
20487 wxDateTime *result;
20488 PyObject * obj0 = 0 ;
20489 PyObject * obj1 = 0 ;
20490 PyObject * obj2 = 0 ;
20491 char *kwnames[] = {
20492 (char *) "self",(char *) "month",(char *) "year", NULL
20493 };
20494
20495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20497 if (SWIG_arg_fail(1)) SWIG_fail;
20498 if (obj1) {
20499 {
20500 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20501 if (SWIG_arg_fail(2)) SWIG_fail;
20502 }
20503 }
20504 if (obj2) {
20505 {
20506 arg3 = (int)(SWIG_As_int(obj2));
20507 if (SWIG_arg_fail(3)) SWIG_fail;
20508 }
20509 }
20510 {
20511 PyThreadState* __tstate = wxPyBeginAllowThreads();
20512 {
20513 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20514 result = (wxDateTime *) &_result_ref;
20515 }
20516
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj;
20529 wxDateTime *arg1 = (wxDateTime *) 0 ;
20530 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20531 int arg3 = (int) wxDateTime::Inv_Year ;
20532 wxDateTime result;
20533 PyObject * obj0 = 0 ;
20534 PyObject * obj1 = 0 ;
20535 PyObject * obj2 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "self",(char *) "month",(char *) "year", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20542 if (SWIG_arg_fail(1)) SWIG_fail;
20543 if (obj1) {
20544 {
20545 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20546 if (SWIG_arg_fail(2)) SWIG_fail;
20547 }
20548 }
20549 if (obj2) {
20550 {
20551 arg3 = (int)(SWIG_As_int(obj2));
20552 if (SWIG_arg_fail(3)) SWIG_fail;
20553 }
20554 }
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20558
20559 wxPyEndAllowThreads(__tstate);
20560 if (PyErr_Occurred()) SWIG_fail;
20561 }
20562 {
20563 wxDateTime * resultptr;
20564 resultptr = new wxDateTime((wxDateTime &)(result));
20565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20566 }
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj;
20575 wxDateTime *arg1 = (wxDateTime *) 0 ;
20576 int arg2 ;
20577 wxDateTime *result;
20578 PyObject * obj0 = 0 ;
20579 PyObject * obj1 = 0 ;
20580 char *kwnames[] = {
20581 (char *) "self",(char *) "yday", NULL
20582 };
20583
20584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20586 if (SWIG_arg_fail(1)) SWIG_fail;
20587 {
20588 arg2 = (int)(SWIG_As_int(obj1));
20589 if (SWIG_arg_fail(2)) SWIG_fail;
20590 }
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 {
20594 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20595 result = (wxDateTime *) &_result_ref;
20596 }
20597
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20602 return resultobj;
20603 fail:
20604 return NULL;
20605 }
20606
20607
20608 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj;
20610 wxDateTime *arg1 = (wxDateTime *) 0 ;
20611 int arg2 ;
20612 wxDateTime result;
20613 PyObject * obj0 = 0 ;
20614 PyObject * obj1 = 0 ;
20615 char *kwnames[] = {
20616 (char *) "self",(char *) "yday", NULL
20617 };
20618
20619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20621 if (SWIG_arg_fail(1)) SWIG_fail;
20622 {
20623 arg2 = (int)(SWIG_As_int(obj1));
20624 if (SWIG_arg_fail(2)) SWIG_fail;
20625 }
20626 {
20627 PyThreadState* __tstate = wxPyBeginAllowThreads();
20628 result = (arg1)->GetYearDay(arg2);
20629
20630 wxPyEndAllowThreads(__tstate);
20631 if (PyErr_Occurred()) SWIG_fail;
20632 }
20633 {
20634 wxDateTime * resultptr;
20635 resultptr = new wxDateTime((wxDateTime &)(result));
20636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj;
20646 wxDateTime *arg1 = (wxDateTime *) 0 ;
20647 double result;
20648 PyObject * obj0 = 0 ;
20649 char *kwnames[] = {
20650 (char *) "self", NULL
20651 };
20652
20653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20655 if (SWIG_arg_fail(1)) SWIG_fail;
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (double)(arg1)->GetJulianDayNumber();
20659
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 {
20664 resultobj = SWIG_From_double((double)(result));
20665 }
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20673 PyObject *resultobj;
20674 wxDateTime *arg1 = (wxDateTime *) 0 ;
20675 double result;
20676 PyObject * obj0 = 0 ;
20677 char *kwnames[] = {
20678 (char *) "self", NULL
20679 };
20680
20681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20683 if (SWIG_arg_fail(1)) SWIG_fail;
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (double)(arg1)->GetJDN();
20687
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 {
20692 resultobj = SWIG_From_double((double)(result));
20693 }
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20701 PyObject *resultobj;
20702 wxDateTime *arg1 = (wxDateTime *) 0 ;
20703 double result;
20704 PyObject * obj0 = 0 ;
20705 char *kwnames[] = {
20706 (char *) "self", NULL
20707 };
20708
20709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20711 if (SWIG_arg_fail(1)) SWIG_fail;
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20715
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 {
20720 resultobj = SWIG_From_double((double)(result));
20721 }
20722 return resultobj;
20723 fail:
20724 return NULL;
20725 }
20726
20727
20728 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20729 PyObject *resultobj;
20730 wxDateTime *arg1 = (wxDateTime *) 0 ;
20731 double result;
20732 PyObject * obj0 = 0 ;
20733 char *kwnames[] = {
20734 (char *) "self", NULL
20735 };
20736
20737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20739 if (SWIG_arg_fail(1)) SWIG_fail;
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = (double)(arg1)->GetMJD();
20743
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 {
20748 resultobj = SWIG_From_double((double)(result));
20749 }
20750 return resultobj;
20751 fail:
20752 return NULL;
20753 }
20754
20755
20756 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20757 PyObject *resultobj;
20758 wxDateTime *arg1 = (wxDateTime *) 0 ;
20759 double result;
20760 PyObject * obj0 = 0 ;
20761 char *kwnames[] = {
20762 (char *) "self", NULL
20763 };
20764
20765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20767 if (SWIG_arg_fail(1)) SWIG_fail;
20768 {
20769 PyThreadState* __tstate = wxPyBeginAllowThreads();
20770 result = (double)(arg1)->GetRataDie();
20771
20772 wxPyEndAllowThreads(__tstate);
20773 if (PyErr_Occurred()) SWIG_fail;
20774 }
20775 {
20776 resultobj = SWIG_From_double((double)(result));
20777 }
20778 return resultobj;
20779 fail:
20780 return NULL;
20781 }
20782
20783
20784 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20785 PyObject *resultobj;
20786 wxDateTime *arg1 = (wxDateTime *) 0 ;
20787 wxDateTime::TimeZone *arg2 = 0 ;
20788 bool arg3 = (bool) false ;
20789 wxDateTime result;
20790 bool temp2 = false ;
20791 PyObject * obj0 = 0 ;
20792 PyObject * obj1 = 0 ;
20793 PyObject * obj2 = 0 ;
20794 char *kwnames[] = {
20795 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20796 };
20797
20798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20800 if (SWIG_arg_fail(1)) SWIG_fail;
20801 {
20802 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20803 temp2 = true;
20804 }
20805 if (obj2) {
20806 {
20807 arg3 = (bool)(SWIG_As_bool(obj2));
20808 if (SWIG_arg_fail(3)) SWIG_fail;
20809 }
20810 }
20811 {
20812 PyThreadState* __tstate = wxPyBeginAllowThreads();
20813 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20814
20815 wxPyEndAllowThreads(__tstate);
20816 if (PyErr_Occurred()) SWIG_fail;
20817 }
20818 {
20819 wxDateTime * resultptr;
20820 resultptr = new wxDateTime((wxDateTime &)(result));
20821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20822 }
20823 {
20824 if (temp2) delete arg2;
20825 }
20826 return resultobj;
20827 fail:
20828 {
20829 if (temp2) delete arg2;
20830 }
20831 return NULL;
20832 }
20833
20834
20835 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 wxDateTime *arg1 = (wxDateTime *) 0 ;
20838 wxDateTime::TimeZone *arg2 = 0 ;
20839 bool arg3 = (bool) false ;
20840 wxDateTime *result;
20841 bool temp2 = false ;
20842 PyObject * obj0 = 0 ;
20843 PyObject * obj1 = 0 ;
20844 PyObject * obj2 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20851 if (SWIG_arg_fail(1)) SWIG_fail;
20852 {
20853 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20854 temp2 = true;
20855 }
20856 if (obj2) {
20857 {
20858 arg3 = (bool)(SWIG_As_bool(obj2));
20859 if (SWIG_arg_fail(3)) SWIG_fail;
20860 }
20861 }
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 {
20865 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20866 result = (wxDateTime *) &_result_ref;
20867 }
20868
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20873 {
20874 if (temp2) delete arg2;
20875 }
20876 return resultobj;
20877 fail:
20878 {
20879 if (temp2) delete arg2;
20880 }
20881 return NULL;
20882 }
20883
20884
20885 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20886 PyObject *resultobj;
20887 wxDateTime *arg1 = (wxDateTime *) 0 ;
20888 bool arg2 = (bool) false ;
20889 wxDateTime result;
20890 PyObject * obj0 = 0 ;
20891 PyObject * obj1 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "self",(char *) "noDST", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20898 if (SWIG_arg_fail(1)) SWIG_fail;
20899 if (obj1) {
20900 {
20901 arg2 = (bool)(SWIG_As_bool(obj1));
20902 if (SWIG_arg_fail(2)) SWIG_fail;
20903 }
20904 }
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (arg1)->ToGMT(arg2);
20908
20909 wxPyEndAllowThreads(__tstate);
20910 if (PyErr_Occurred()) SWIG_fail;
20911 }
20912 {
20913 wxDateTime * resultptr;
20914 resultptr = new wxDateTime((wxDateTime &)(result));
20915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20916 }
20917 return resultobj;
20918 fail:
20919 return NULL;
20920 }
20921
20922
20923 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20924 PyObject *resultobj;
20925 wxDateTime *arg1 = (wxDateTime *) 0 ;
20926 bool arg2 = (bool) false ;
20927 wxDateTime *result;
20928 PyObject * obj0 = 0 ;
20929 PyObject * obj1 = 0 ;
20930 char *kwnames[] = {
20931 (char *) "self",(char *) "noDST", NULL
20932 };
20933
20934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20936 if (SWIG_arg_fail(1)) SWIG_fail;
20937 if (obj1) {
20938 {
20939 arg2 = (bool)(SWIG_As_bool(obj1));
20940 if (SWIG_arg_fail(2)) SWIG_fail;
20941 }
20942 }
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 {
20946 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20947 result = (wxDateTime *) &_result_ref;
20948 }
20949
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20961 PyObject *resultobj;
20962 wxDateTime *arg1 = (wxDateTime *) 0 ;
20963 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20964 int result;
20965 PyObject * obj0 = 0 ;
20966 PyObject * obj1 = 0 ;
20967 char *kwnames[] = {
20968 (char *) "self",(char *) "country", NULL
20969 };
20970
20971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20973 if (SWIG_arg_fail(1)) SWIG_fail;
20974 if (obj1) {
20975 {
20976 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20977 if (SWIG_arg_fail(2)) SWIG_fail;
20978 }
20979 }
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 {
20988 resultobj = SWIG_From_int((int)(result));
20989 }
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj;
20998 wxDateTime *arg1 = (wxDateTime *) 0 ;
20999 bool result;
21000 PyObject * obj0 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 PyThreadState* __tstate = wxPyBeginAllowThreads();
21010 result = (bool)((wxDateTime const *)arg1)->IsValid();
21011
21012 wxPyEndAllowThreads(__tstate);
21013 if (PyErr_Occurred()) SWIG_fail;
21014 }
21015 {
21016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21017 }
21018 return resultobj;
21019 fail:
21020 return NULL;
21021 }
21022
21023
21024 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21025 PyObject *resultobj;
21026 wxDateTime *arg1 = (wxDateTime *) 0 ;
21027 time_t result;
21028 PyObject * obj0 = 0 ;
21029 char *kwnames[] = {
21030 (char *) "self", NULL
21031 };
21032
21033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21035 if (SWIG_arg_fail(1)) SWIG_fail;
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21039
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 {
21044 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21045 }
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj;
21054 wxDateTime *arg1 = (wxDateTime *) 0 ;
21055 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21056 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21057 int result;
21058 bool temp2 = false ;
21059 PyObject * obj0 = 0 ;
21060 PyObject * obj1 = 0 ;
21061 char *kwnames[] = {
21062 (char *) "self",(char *) "tz", NULL
21063 };
21064
21065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21067 if (SWIG_arg_fail(1)) SWIG_fail;
21068 if (obj1) {
21069 {
21070 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21071 temp2 = true;
21072 }
21073 }
21074 {
21075 PyThreadState* __tstate = wxPyBeginAllowThreads();
21076 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21077
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 {
21082 resultobj = SWIG_From_int((int)(result));
21083 }
21084 {
21085 if (temp2) delete arg2;
21086 }
21087 return resultobj;
21088 fail:
21089 {
21090 if (temp2) delete arg2;
21091 }
21092 return NULL;
21093 }
21094
21095
21096 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21097 PyObject *resultobj;
21098 wxDateTime *arg1 = (wxDateTime *) 0 ;
21099 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21100 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21101 wxDateTime::Month result;
21102 bool temp2 = false ;
21103 PyObject * obj0 = 0 ;
21104 PyObject * obj1 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "self",(char *) "tz", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 if (obj1) {
21113 {
21114 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21115 temp2 = true;
21116 }
21117 }
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21121
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 resultobj = SWIG_From_int((result));
21126 {
21127 if (temp2) delete arg2;
21128 }
21129 return resultobj;
21130 fail:
21131 {
21132 if (temp2) delete arg2;
21133 }
21134 return NULL;
21135 }
21136
21137
21138 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21139 PyObject *resultobj;
21140 wxDateTime *arg1 = (wxDateTime *) 0 ;
21141 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21142 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21143 int result;
21144 bool temp2 = false ;
21145 PyObject * obj0 = 0 ;
21146 PyObject * obj1 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self",(char *) "tz", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 if (obj1) {
21155 {
21156 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21157 temp2 = true;
21158 }
21159 }
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21163
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 resultobj = SWIG_From_int((int)(result));
21169 }
21170 {
21171 if (temp2) delete arg2;
21172 }
21173 return resultobj;
21174 fail:
21175 {
21176 if (temp2) delete arg2;
21177 }
21178 return NULL;
21179 }
21180
21181
21182 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj;
21184 wxDateTime *arg1 = (wxDateTime *) 0 ;
21185 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21186 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21187 wxDateTime::WeekDay result;
21188 bool temp2 = false ;
21189 PyObject * obj0 = 0 ;
21190 PyObject * obj1 = 0 ;
21191 char *kwnames[] = {
21192 (char *) "self",(char *) "tz", NULL
21193 };
21194
21195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21197 if (SWIG_arg_fail(1)) SWIG_fail;
21198 if (obj1) {
21199 {
21200 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21201 temp2 = true;
21202 }
21203 }
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21207
21208 wxPyEndAllowThreads(__tstate);
21209 if (PyErr_Occurred()) SWIG_fail;
21210 }
21211 resultobj = SWIG_From_int((result));
21212 {
21213 if (temp2) delete arg2;
21214 }
21215 return resultobj;
21216 fail:
21217 {
21218 if (temp2) delete arg2;
21219 }
21220 return NULL;
21221 }
21222
21223
21224 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21225 PyObject *resultobj;
21226 wxDateTime *arg1 = (wxDateTime *) 0 ;
21227 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21228 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21229 int result;
21230 bool temp2 = false ;
21231 PyObject * obj0 = 0 ;
21232 PyObject * obj1 = 0 ;
21233 char *kwnames[] = {
21234 (char *) "self",(char *) "tz", NULL
21235 };
21236
21237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21239 if (SWIG_arg_fail(1)) SWIG_fail;
21240 if (obj1) {
21241 {
21242 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21243 temp2 = true;
21244 }
21245 }
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = SWIG_From_int((int)(result));
21255 }
21256 {
21257 if (temp2) delete arg2;
21258 }
21259 return resultobj;
21260 fail:
21261 {
21262 if (temp2) delete arg2;
21263 }
21264 return NULL;
21265 }
21266
21267
21268 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj;
21270 wxDateTime *arg1 = (wxDateTime *) 0 ;
21271 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21272 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21273 int result;
21274 bool temp2 = false ;
21275 PyObject * obj0 = 0 ;
21276 PyObject * obj1 = 0 ;
21277 char *kwnames[] = {
21278 (char *) "self",(char *) "tz", NULL
21279 };
21280
21281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21283 if (SWIG_arg_fail(1)) SWIG_fail;
21284 if (obj1) {
21285 {
21286 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21287 temp2 = true;
21288 }
21289 }
21290 {
21291 PyThreadState* __tstate = wxPyBeginAllowThreads();
21292 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 {
21298 resultobj = SWIG_From_int((int)(result));
21299 }
21300 {
21301 if (temp2) delete arg2;
21302 }
21303 return resultobj;
21304 fail:
21305 {
21306 if (temp2) delete arg2;
21307 }
21308 return NULL;
21309 }
21310
21311
21312 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21313 PyObject *resultobj;
21314 wxDateTime *arg1 = (wxDateTime *) 0 ;
21315 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21316 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21317 int result;
21318 bool temp2 = false ;
21319 PyObject * obj0 = 0 ;
21320 PyObject * obj1 = 0 ;
21321 char *kwnames[] = {
21322 (char *) "self",(char *) "tz", NULL
21323 };
21324
21325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21327 if (SWIG_arg_fail(1)) SWIG_fail;
21328 if (obj1) {
21329 {
21330 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21331 temp2 = true;
21332 }
21333 }
21334 {
21335 PyThreadState* __tstate = wxPyBeginAllowThreads();
21336 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 {
21342 resultobj = SWIG_From_int((int)(result));
21343 }
21344 {
21345 if (temp2) delete arg2;
21346 }
21347 return resultobj;
21348 fail:
21349 {
21350 if (temp2) delete arg2;
21351 }
21352 return NULL;
21353 }
21354
21355
21356 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21357 PyObject *resultobj;
21358 wxDateTime *arg1 = (wxDateTime *) 0 ;
21359 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21360 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21361 int result;
21362 bool temp2 = false ;
21363 PyObject * obj0 = 0 ;
21364 PyObject * obj1 = 0 ;
21365 char *kwnames[] = {
21366 (char *) "self",(char *) "tz", NULL
21367 };
21368
21369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21371 if (SWIG_arg_fail(1)) SWIG_fail;
21372 if (obj1) {
21373 {
21374 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21375 temp2 = true;
21376 }
21377 }
21378 {
21379 PyThreadState* __tstate = wxPyBeginAllowThreads();
21380 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21381
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 {
21386 resultobj = SWIG_From_int((int)(result));
21387 }
21388 {
21389 if (temp2) delete arg2;
21390 }
21391 return resultobj;
21392 fail:
21393 {
21394 if (temp2) delete arg2;
21395 }
21396 return NULL;
21397 }
21398
21399
21400 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21401 PyObject *resultobj;
21402 wxDateTime *arg1 = (wxDateTime *) 0 ;
21403 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21404 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21405 int result;
21406 bool temp2 = false ;
21407 PyObject * obj0 = 0 ;
21408 PyObject * obj1 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "self",(char *) "tz", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 if (obj1) {
21417 {
21418 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21419 temp2 = true;
21420 }
21421 }
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21425
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 {
21430 resultobj = SWIG_From_int((int)(result));
21431 }
21432 {
21433 if (temp2) delete arg2;
21434 }
21435 return resultobj;
21436 fail:
21437 {
21438 if (temp2) delete arg2;
21439 }
21440 return NULL;
21441 }
21442
21443
21444 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21445 PyObject *resultobj;
21446 wxDateTime *arg1 = (wxDateTime *) 0 ;
21447 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21448 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21449 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21450 int result;
21451 bool temp3 = false ;
21452 PyObject * obj0 = 0 ;
21453 PyObject * obj1 = 0 ;
21454 PyObject * obj2 = 0 ;
21455 char *kwnames[] = {
21456 (char *) "self",(char *) "flags",(char *) "tz", NULL
21457 };
21458
21459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21461 if (SWIG_arg_fail(1)) SWIG_fail;
21462 if (obj1) {
21463 {
21464 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21465 if (SWIG_arg_fail(2)) SWIG_fail;
21466 }
21467 }
21468 if (obj2) {
21469 {
21470 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21471 temp3 = true;
21472 }
21473 }
21474 {
21475 PyThreadState* __tstate = wxPyBeginAllowThreads();
21476 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21477
21478 wxPyEndAllowThreads(__tstate);
21479 if (PyErr_Occurred()) SWIG_fail;
21480 }
21481 {
21482 resultobj = SWIG_From_int((int)(result));
21483 }
21484 {
21485 if (temp3) delete arg3;
21486 }
21487 return resultobj;
21488 fail:
21489 {
21490 if (temp3) delete arg3;
21491 }
21492 return NULL;
21493 }
21494
21495
21496 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21497 PyObject *resultobj;
21498 wxDateTime *arg1 = (wxDateTime *) 0 ;
21499 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21500 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21501 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21502 int result;
21503 bool temp3 = false ;
21504 PyObject * obj0 = 0 ;
21505 PyObject * obj1 = 0 ;
21506 PyObject * obj2 = 0 ;
21507 char *kwnames[] = {
21508 (char *) "self",(char *) "flags",(char *) "tz", NULL
21509 };
21510
21511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21513 if (SWIG_arg_fail(1)) SWIG_fail;
21514 if (obj1) {
21515 {
21516 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21517 if (SWIG_arg_fail(2)) SWIG_fail;
21518 }
21519 }
21520 if (obj2) {
21521 {
21522 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21523 temp3 = true;
21524 }
21525 }
21526 {
21527 PyThreadState* __tstate = wxPyBeginAllowThreads();
21528 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21529
21530 wxPyEndAllowThreads(__tstate);
21531 if (PyErr_Occurred()) SWIG_fail;
21532 }
21533 {
21534 resultobj = SWIG_From_int((int)(result));
21535 }
21536 {
21537 if (temp3) delete arg3;
21538 }
21539 return resultobj;
21540 fail:
21541 {
21542 if (temp3) delete arg3;
21543 }
21544 return NULL;
21545 }
21546
21547
21548 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21549 PyObject *resultobj;
21550 wxDateTime *arg1 = (wxDateTime *) 0 ;
21551 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21552 bool result;
21553 PyObject * obj0 = 0 ;
21554 PyObject * obj1 = 0 ;
21555 char *kwnames[] = {
21556 (char *) "self",(char *) "country", NULL
21557 };
21558
21559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21561 if (SWIG_arg_fail(1)) SWIG_fail;
21562 if (obj1) {
21563 {
21564 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21565 if (SWIG_arg_fail(2)) SWIG_fail;
21566 }
21567 }
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21571
21572 wxPyEndAllowThreads(__tstate);
21573 if (PyErr_Occurred()) SWIG_fail;
21574 }
21575 {
21576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21577 }
21578 return resultobj;
21579 fail:
21580 return NULL;
21581 }
21582
21583
21584 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21585 PyObject *resultobj;
21586 wxDateTime *arg1 = (wxDateTime *) 0 ;
21587 wxDateTime *arg2 = 0 ;
21588 bool result;
21589 PyObject * obj0 = 0 ;
21590 PyObject * obj1 = 0 ;
21591 char *kwnames[] = {
21592 (char *) "self",(char *) "datetime", NULL
21593 };
21594
21595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21597 if (SWIG_arg_fail(1)) SWIG_fail;
21598 {
21599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21600 if (SWIG_arg_fail(2)) SWIG_fail;
21601 if (arg2 == NULL) {
21602 SWIG_null_ref("wxDateTime");
21603 }
21604 if (SWIG_arg_fail(2)) SWIG_fail;
21605 }
21606 {
21607 PyThreadState* __tstate = wxPyBeginAllowThreads();
21608 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21609
21610 wxPyEndAllowThreads(__tstate);
21611 if (PyErr_Occurred()) SWIG_fail;
21612 }
21613 {
21614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21615 }
21616 return resultobj;
21617 fail:
21618 return NULL;
21619 }
21620
21621
21622 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj;
21624 wxDateTime *arg1 = (wxDateTime *) 0 ;
21625 wxDateTime *arg2 = 0 ;
21626 bool result;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "datetime", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 {
21637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21638 if (SWIG_arg_fail(2)) SWIG_fail;
21639 if (arg2 == NULL) {
21640 SWIG_null_ref("wxDateTime");
21641 }
21642 if (SWIG_arg_fail(2)) SWIG_fail;
21643 }
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21647
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 {
21652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21653 }
21654 return resultobj;
21655 fail:
21656 return NULL;
21657 }
21658
21659
21660 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21661 PyObject *resultobj;
21662 wxDateTime *arg1 = (wxDateTime *) 0 ;
21663 wxDateTime *arg2 = 0 ;
21664 bool result;
21665 PyObject * obj0 = 0 ;
21666 PyObject * obj1 = 0 ;
21667 char *kwnames[] = {
21668 (char *) "self",(char *) "datetime", NULL
21669 };
21670
21671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21673 if (SWIG_arg_fail(1)) SWIG_fail;
21674 {
21675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21676 if (SWIG_arg_fail(2)) SWIG_fail;
21677 if (arg2 == NULL) {
21678 SWIG_null_ref("wxDateTime");
21679 }
21680 if (SWIG_arg_fail(2)) SWIG_fail;
21681 }
21682 {
21683 PyThreadState* __tstate = wxPyBeginAllowThreads();
21684 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21685
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 {
21690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21691 }
21692 return resultobj;
21693 fail:
21694 return NULL;
21695 }
21696
21697
21698 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21699 PyObject *resultobj;
21700 wxDateTime *arg1 = (wxDateTime *) 0 ;
21701 wxDateTime *arg2 = 0 ;
21702 wxDateTime *arg3 = 0 ;
21703 bool result;
21704 PyObject * obj0 = 0 ;
21705 PyObject * obj1 = 0 ;
21706 PyObject * obj2 = 0 ;
21707 char *kwnames[] = {
21708 (char *) "self",(char *) "t1",(char *) "t2", NULL
21709 };
21710
21711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21713 if (SWIG_arg_fail(1)) SWIG_fail;
21714 {
21715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21716 if (SWIG_arg_fail(2)) SWIG_fail;
21717 if (arg2 == NULL) {
21718 SWIG_null_ref("wxDateTime");
21719 }
21720 if (SWIG_arg_fail(2)) SWIG_fail;
21721 }
21722 {
21723 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21724 if (SWIG_arg_fail(3)) SWIG_fail;
21725 if (arg3 == NULL) {
21726 SWIG_null_ref("wxDateTime");
21727 }
21728 if (SWIG_arg_fail(3)) SWIG_fail;
21729 }
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21733
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 {
21738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21739 }
21740 return resultobj;
21741 fail:
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxDateTime *arg1 = (wxDateTime *) 0 ;
21749 wxDateTime *arg2 = 0 ;
21750 wxDateTime *arg3 = 0 ;
21751 bool result;
21752 PyObject * obj0 = 0 ;
21753 PyObject * obj1 = 0 ;
21754 PyObject * obj2 = 0 ;
21755 char *kwnames[] = {
21756 (char *) "self",(char *) "t1",(char *) "t2", NULL
21757 };
21758
21759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21761 if (SWIG_arg_fail(1)) SWIG_fail;
21762 {
21763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21764 if (SWIG_arg_fail(2)) SWIG_fail;
21765 if (arg2 == NULL) {
21766 SWIG_null_ref("wxDateTime");
21767 }
21768 if (SWIG_arg_fail(2)) SWIG_fail;
21769 }
21770 {
21771 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21772 if (SWIG_arg_fail(3)) SWIG_fail;
21773 if (arg3 == NULL) {
21774 SWIG_null_ref("wxDateTime");
21775 }
21776 if (SWIG_arg_fail(3)) SWIG_fail;
21777 }
21778 {
21779 PyThreadState* __tstate = wxPyBeginAllowThreads();
21780 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21781
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 {
21786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21787 }
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21795 PyObject *resultobj;
21796 wxDateTime *arg1 = (wxDateTime *) 0 ;
21797 wxDateTime *arg2 = 0 ;
21798 bool result;
21799 PyObject * obj0 = 0 ;
21800 PyObject * obj1 = 0 ;
21801 char *kwnames[] = {
21802 (char *) "self",(char *) "dt", NULL
21803 };
21804
21805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21807 if (SWIG_arg_fail(1)) SWIG_fail;
21808 {
21809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21810 if (SWIG_arg_fail(2)) SWIG_fail;
21811 if (arg2 == NULL) {
21812 SWIG_null_ref("wxDateTime");
21813 }
21814 if (SWIG_arg_fail(2)) SWIG_fail;
21815 }
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21819
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 {
21824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21825 }
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxDateTime *arg1 = (wxDateTime *) 0 ;
21835 wxDateTime *arg2 = 0 ;
21836 bool result;
21837 PyObject * obj0 = 0 ;
21838 PyObject * obj1 = 0 ;
21839 char *kwnames[] = {
21840 (char *) "self",(char *) "dt", NULL
21841 };
21842
21843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21845 if (SWIG_arg_fail(1)) SWIG_fail;
21846 {
21847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(2)) SWIG_fail;
21849 if (arg2 == NULL) {
21850 SWIG_null_ref("wxDateTime");
21851 }
21852 if (SWIG_arg_fail(2)) SWIG_fail;
21853 }
21854 {
21855 PyThreadState* __tstate = wxPyBeginAllowThreads();
21856 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21857
21858 wxPyEndAllowThreads(__tstate);
21859 if (PyErr_Occurred()) SWIG_fail;
21860 }
21861 {
21862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21863 }
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21871 PyObject *resultobj;
21872 wxDateTime *arg1 = (wxDateTime *) 0 ;
21873 wxDateTime *arg2 = 0 ;
21874 wxTimeSpan *arg3 = 0 ;
21875 bool result;
21876 PyObject * obj0 = 0 ;
21877 PyObject * obj1 = 0 ;
21878 PyObject * obj2 = 0 ;
21879 char *kwnames[] = {
21880 (char *) "self",(char *) "dt",(char *) "ts", NULL
21881 };
21882
21883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21885 if (SWIG_arg_fail(1)) SWIG_fail;
21886 {
21887 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21888 if (SWIG_arg_fail(2)) SWIG_fail;
21889 if (arg2 == NULL) {
21890 SWIG_null_ref("wxDateTime");
21891 }
21892 if (SWIG_arg_fail(2)) SWIG_fail;
21893 }
21894 {
21895 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21896 if (SWIG_arg_fail(3)) SWIG_fail;
21897 if (arg3 == NULL) {
21898 SWIG_null_ref("wxTimeSpan");
21899 }
21900 if (SWIG_arg_fail(3)) SWIG_fail;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21905
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 {
21910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21911 }
21912 return resultobj;
21913 fail:
21914 return NULL;
21915 }
21916
21917
21918 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21919 PyObject *resultobj;
21920 wxDateTime *arg1 = (wxDateTime *) 0 ;
21921 wxTimeSpan *arg2 = 0 ;
21922 wxDateTime *result;
21923 PyObject * obj0 = 0 ;
21924 PyObject * obj1 = 0 ;
21925 char *kwnames[] = {
21926 (char *) "self",(char *) "diff", NULL
21927 };
21928
21929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21931 if (SWIG_arg_fail(1)) SWIG_fail;
21932 {
21933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21934 if (SWIG_arg_fail(2)) SWIG_fail;
21935 if (arg2 == NULL) {
21936 SWIG_null_ref("wxTimeSpan");
21937 }
21938 if (SWIG_arg_fail(2)) SWIG_fail;
21939 }
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 {
21943 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21944 result = (wxDateTime *) &_result_ref;
21945 }
21946
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21958 PyObject *resultobj;
21959 wxDateTime *arg1 = (wxDateTime *) 0 ;
21960 wxDateSpan *arg2 = 0 ;
21961 wxDateTime *result;
21962 PyObject * obj0 = 0 ;
21963 PyObject * obj1 = 0 ;
21964 char *kwnames[] = {
21965 (char *) "self",(char *) "diff", NULL
21966 };
21967
21968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21970 if (SWIG_arg_fail(1)) SWIG_fail;
21971 {
21972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21973 if (SWIG_arg_fail(2)) SWIG_fail;
21974 if (arg2 == NULL) {
21975 SWIG_null_ref("wxDateSpan");
21976 }
21977 if (SWIG_arg_fail(2)) SWIG_fail;
21978 }
21979 {
21980 PyThreadState* __tstate = wxPyBeginAllowThreads();
21981 {
21982 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21983 result = (wxDateTime *) &_result_ref;
21984 }
21985
21986 wxPyEndAllowThreads(__tstate);
21987 if (PyErr_Occurred()) SWIG_fail;
21988 }
21989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21990 return resultobj;
21991 fail:
21992 return NULL;
21993 }
21994
21995
21996 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
21997 PyObject *resultobj;
21998 wxDateTime *arg1 = (wxDateTime *) 0 ;
21999 wxTimeSpan *arg2 = 0 ;
22000 wxDateTime *result;
22001 PyObject * obj0 = 0 ;
22002 PyObject * obj1 = 0 ;
22003 char *kwnames[] = {
22004 (char *) "self",(char *) "diff", NULL
22005 };
22006
22007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22009 if (SWIG_arg_fail(1)) SWIG_fail;
22010 {
22011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22012 if (SWIG_arg_fail(2)) SWIG_fail;
22013 if (arg2 == NULL) {
22014 SWIG_null_ref("wxTimeSpan");
22015 }
22016 if (SWIG_arg_fail(2)) SWIG_fail;
22017 }
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 {
22021 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22022 result = (wxDateTime *) &_result_ref;
22023 }
22024
22025 wxPyEndAllowThreads(__tstate);
22026 if (PyErr_Occurred()) SWIG_fail;
22027 }
22028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22036 PyObject *resultobj;
22037 wxDateTime *arg1 = (wxDateTime *) 0 ;
22038 wxDateSpan *arg2 = 0 ;
22039 wxDateTime *result;
22040 PyObject * obj0 = 0 ;
22041 PyObject * obj1 = 0 ;
22042 char *kwnames[] = {
22043 (char *) "self",(char *) "diff", NULL
22044 };
22045
22046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22048 if (SWIG_arg_fail(1)) SWIG_fail;
22049 {
22050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22051 if (SWIG_arg_fail(2)) SWIG_fail;
22052 if (arg2 == NULL) {
22053 SWIG_null_ref("wxDateSpan");
22054 }
22055 if (SWIG_arg_fail(2)) SWIG_fail;
22056 }
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 {
22060 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22061 result = (wxDateTime *) &_result_ref;
22062 }
22063
22064 wxPyEndAllowThreads(__tstate);
22065 if (PyErr_Occurred()) SWIG_fail;
22066 }
22067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22068 return resultobj;
22069 fail:
22070 return NULL;
22071 }
22072
22073
22074 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22075 PyObject *resultobj;
22076 wxDateTime *arg1 = (wxDateTime *) 0 ;
22077 wxDateTime *arg2 = 0 ;
22078 wxTimeSpan result;
22079 PyObject * obj0 = 0 ;
22080 PyObject * obj1 = 0 ;
22081 char *kwnames[] = {
22082 (char *) "self",(char *) "dt", NULL
22083 };
22084
22085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22087 if (SWIG_arg_fail(1)) SWIG_fail;
22088 {
22089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22090 if (SWIG_arg_fail(2)) SWIG_fail;
22091 if (arg2 == NULL) {
22092 SWIG_null_ref("wxDateTime");
22093 }
22094 if (SWIG_arg_fail(2)) SWIG_fail;
22095 }
22096 {
22097 PyThreadState* __tstate = wxPyBeginAllowThreads();
22098 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22099
22100 wxPyEndAllowThreads(__tstate);
22101 if (PyErr_Occurred()) SWIG_fail;
22102 }
22103 {
22104 wxTimeSpan * resultptr;
22105 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22107 }
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22115 PyObject *resultobj;
22116 wxDateTime *arg1 = (wxDateTime *) 0 ;
22117 wxTimeSpan *arg2 = 0 ;
22118 wxDateTime *result;
22119 PyObject * obj0 = 0 ;
22120 PyObject * obj1 = 0 ;
22121
22122 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22124 if (SWIG_arg_fail(1)) SWIG_fail;
22125 {
22126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22127 if (SWIG_arg_fail(2)) SWIG_fail;
22128 if (arg2 == NULL) {
22129 SWIG_null_ref("wxTimeSpan");
22130 }
22131 if (SWIG_arg_fail(2)) SWIG_fail;
22132 }
22133 {
22134 PyThreadState* __tstate = wxPyBeginAllowThreads();
22135 {
22136 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22137 result = (wxDateTime *) &_result_ref;
22138 }
22139
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22151 PyObject *resultobj;
22152 wxDateTime *arg1 = (wxDateTime *) 0 ;
22153 wxDateSpan *arg2 = 0 ;
22154 wxDateTime *result;
22155 PyObject * obj0 = 0 ;
22156 PyObject * obj1 = 0 ;
22157
22158 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22160 if (SWIG_arg_fail(1)) SWIG_fail;
22161 {
22162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22163 if (SWIG_arg_fail(2)) SWIG_fail;
22164 if (arg2 == NULL) {
22165 SWIG_null_ref("wxDateSpan");
22166 }
22167 if (SWIG_arg_fail(2)) SWIG_fail;
22168 }
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 {
22172 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22173 result = (wxDateTime *) &_result_ref;
22174 }
22175
22176 wxPyEndAllowThreads(__tstate);
22177 if (PyErr_Occurred()) SWIG_fail;
22178 }
22179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22180 return resultobj;
22181 fail:
22182 return NULL;
22183 }
22184
22185
22186 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22187 int argc;
22188 PyObject *argv[3];
22189 int ii;
22190
22191 argc = PyObject_Length(args);
22192 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22193 argv[ii] = PyTuple_GetItem(args,ii);
22194 }
22195 if (argc == 2) {
22196 int _v;
22197 {
22198 void *ptr;
22199 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22200 _v = 0;
22201 PyErr_Clear();
22202 } else {
22203 _v = 1;
22204 }
22205 }
22206 if (_v) {
22207 {
22208 void *ptr = 0;
22209 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22210 _v = 0;
22211 PyErr_Clear();
22212 } else {
22213 _v = (ptr != 0);
22214 }
22215 }
22216 if (_v) {
22217 return _wrap_DateTime___iadd____SWIG_0(self,args);
22218 }
22219 }
22220 }
22221 if (argc == 2) {
22222 int _v;
22223 {
22224 void *ptr;
22225 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22226 _v = 0;
22227 PyErr_Clear();
22228 } else {
22229 _v = 1;
22230 }
22231 }
22232 if (_v) {
22233 {
22234 void *ptr = 0;
22235 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22236 _v = 0;
22237 PyErr_Clear();
22238 } else {
22239 _v = (ptr != 0);
22240 }
22241 }
22242 if (_v) {
22243 return _wrap_DateTime___iadd____SWIG_1(self,args);
22244 }
22245 }
22246 }
22247
22248 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22249 return NULL;
22250 }
22251
22252
22253 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22254 PyObject *resultobj;
22255 wxDateTime *arg1 = (wxDateTime *) 0 ;
22256 wxTimeSpan *arg2 = 0 ;
22257 wxDateTime *result;
22258 PyObject * obj0 = 0 ;
22259 PyObject * obj1 = 0 ;
22260
22261 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22263 if (SWIG_arg_fail(1)) SWIG_fail;
22264 {
22265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22266 if (SWIG_arg_fail(2)) SWIG_fail;
22267 if (arg2 == NULL) {
22268 SWIG_null_ref("wxTimeSpan");
22269 }
22270 if (SWIG_arg_fail(2)) SWIG_fail;
22271 }
22272 {
22273 PyThreadState* __tstate = wxPyBeginAllowThreads();
22274 {
22275 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22276 result = (wxDateTime *) &_result_ref;
22277 }
22278
22279 wxPyEndAllowThreads(__tstate);
22280 if (PyErr_Occurred()) SWIG_fail;
22281 }
22282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22290 PyObject *resultobj;
22291 wxDateTime *arg1 = (wxDateTime *) 0 ;
22292 wxDateSpan *arg2 = 0 ;
22293 wxDateTime *result;
22294 PyObject * obj0 = 0 ;
22295 PyObject * obj1 = 0 ;
22296
22297 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22299 if (SWIG_arg_fail(1)) SWIG_fail;
22300 {
22301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22302 if (SWIG_arg_fail(2)) SWIG_fail;
22303 if (arg2 == NULL) {
22304 SWIG_null_ref("wxDateSpan");
22305 }
22306 if (SWIG_arg_fail(2)) SWIG_fail;
22307 }
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 {
22311 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22312 result = (wxDateTime *) &_result_ref;
22313 }
22314
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22326 int argc;
22327 PyObject *argv[3];
22328 int ii;
22329
22330 argc = PyObject_Length(args);
22331 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22332 argv[ii] = PyTuple_GetItem(args,ii);
22333 }
22334 if (argc == 2) {
22335 int _v;
22336 {
22337 void *ptr;
22338 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22339 _v = 0;
22340 PyErr_Clear();
22341 } else {
22342 _v = 1;
22343 }
22344 }
22345 if (_v) {
22346 {
22347 void *ptr = 0;
22348 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22349 _v = 0;
22350 PyErr_Clear();
22351 } else {
22352 _v = (ptr != 0);
22353 }
22354 }
22355 if (_v) {
22356 return _wrap_DateTime___isub____SWIG_0(self,args);
22357 }
22358 }
22359 }
22360 if (argc == 2) {
22361 int _v;
22362 {
22363 void *ptr;
22364 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22365 _v = 0;
22366 PyErr_Clear();
22367 } else {
22368 _v = 1;
22369 }
22370 }
22371 if (_v) {
22372 {
22373 void *ptr = 0;
22374 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22375 _v = 0;
22376 PyErr_Clear();
22377 } else {
22378 _v = (ptr != 0);
22379 }
22380 }
22381 if (_v) {
22382 return _wrap_DateTime___isub____SWIG_1(self,args);
22383 }
22384 }
22385 }
22386
22387 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22388 return NULL;
22389 }
22390
22391
22392 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22393 PyObject *resultobj;
22394 wxDateTime *arg1 = (wxDateTime *) 0 ;
22395 wxTimeSpan *arg2 = 0 ;
22396 wxDateTime result;
22397 PyObject * obj0 = 0 ;
22398 PyObject * obj1 = 0 ;
22399
22400 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(1)) SWIG_fail;
22403 {
22404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22405 if (SWIG_arg_fail(2)) SWIG_fail;
22406 if (arg2 == NULL) {
22407 SWIG_null_ref("wxTimeSpan");
22408 }
22409 if (SWIG_arg_fail(2)) SWIG_fail;
22410 }
22411 {
22412 PyThreadState* __tstate = wxPyBeginAllowThreads();
22413 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22414
22415 wxPyEndAllowThreads(__tstate);
22416 if (PyErr_Occurred()) SWIG_fail;
22417 }
22418 {
22419 wxDateTime * resultptr;
22420 resultptr = new wxDateTime((wxDateTime &)(result));
22421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22422 }
22423 return resultobj;
22424 fail:
22425 return NULL;
22426 }
22427
22428
22429 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22430 PyObject *resultobj;
22431 wxDateTime *arg1 = (wxDateTime *) 0 ;
22432 wxDateSpan *arg2 = 0 ;
22433 wxDateTime result;
22434 PyObject * obj0 = 0 ;
22435 PyObject * obj1 = 0 ;
22436
22437 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22439 if (SWIG_arg_fail(1)) SWIG_fail;
22440 {
22441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22442 if (SWIG_arg_fail(2)) SWIG_fail;
22443 if (arg2 == NULL) {
22444 SWIG_null_ref("wxDateSpan");
22445 }
22446 if (SWIG_arg_fail(2)) SWIG_fail;
22447 }
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22451
22452 wxPyEndAllowThreads(__tstate);
22453 if (PyErr_Occurred()) SWIG_fail;
22454 }
22455 {
22456 wxDateTime * resultptr;
22457 resultptr = new wxDateTime((wxDateTime &)(result));
22458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22459 }
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22467 int argc;
22468 PyObject *argv[3];
22469 int ii;
22470
22471 argc = PyObject_Length(args);
22472 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22473 argv[ii] = PyTuple_GetItem(args,ii);
22474 }
22475 if (argc == 2) {
22476 int _v;
22477 {
22478 void *ptr;
22479 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22480 _v = 0;
22481 PyErr_Clear();
22482 } else {
22483 _v = 1;
22484 }
22485 }
22486 if (_v) {
22487 {
22488 void *ptr = 0;
22489 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22490 _v = 0;
22491 PyErr_Clear();
22492 } else {
22493 _v = (ptr != 0);
22494 }
22495 }
22496 if (_v) {
22497 return _wrap_DateTime___add____SWIG_0(self,args);
22498 }
22499 }
22500 }
22501 if (argc == 2) {
22502 int _v;
22503 {
22504 void *ptr;
22505 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22506 _v = 0;
22507 PyErr_Clear();
22508 } else {
22509 _v = 1;
22510 }
22511 }
22512 if (_v) {
22513 {
22514 void *ptr = 0;
22515 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22516 _v = 0;
22517 PyErr_Clear();
22518 } else {
22519 _v = (ptr != 0);
22520 }
22521 }
22522 if (_v) {
22523 return _wrap_DateTime___add____SWIG_1(self,args);
22524 }
22525 }
22526 }
22527
22528 Py_INCREF(Py_NotImplemented);
22529 return Py_NotImplemented;
22530 }
22531
22532
22533 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22534 PyObject *resultobj;
22535 wxDateTime *arg1 = (wxDateTime *) 0 ;
22536 wxDateTime *arg2 = 0 ;
22537 wxTimeSpan result;
22538 PyObject * obj0 = 0 ;
22539 PyObject * obj1 = 0 ;
22540
22541 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(1)) SWIG_fail;
22544 {
22545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22546 if (SWIG_arg_fail(2)) SWIG_fail;
22547 if (arg2 == NULL) {
22548 SWIG_null_ref("wxDateTime");
22549 }
22550 if (SWIG_arg_fail(2)) SWIG_fail;
22551 }
22552 {
22553 PyThreadState* __tstate = wxPyBeginAllowThreads();
22554 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22555
22556 wxPyEndAllowThreads(__tstate);
22557 if (PyErr_Occurred()) SWIG_fail;
22558 }
22559 {
22560 wxTimeSpan * resultptr;
22561 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22563 }
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22571 PyObject *resultobj;
22572 wxDateTime *arg1 = (wxDateTime *) 0 ;
22573 wxTimeSpan *arg2 = 0 ;
22574 wxDateTime result;
22575 PyObject * obj0 = 0 ;
22576 PyObject * obj1 = 0 ;
22577
22578 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22580 if (SWIG_arg_fail(1)) SWIG_fail;
22581 {
22582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22583 if (SWIG_arg_fail(2)) SWIG_fail;
22584 if (arg2 == NULL) {
22585 SWIG_null_ref("wxTimeSpan");
22586 }
22587 if (SWIG_arg_fail(2)) SWIG_fail;
22588 }
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22592
22593 wxPyEndAllowThreads(__tstate);
22594 if (PyErr_Occurred()) SWIG_fail;
22595 }
22596 {
22597 wxDateTime * resultptr;
22598 resultptr = new wxDateTime((wxDateTime &)(result));
22599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22600 }
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22608 PyObject *resultobj;
22609 wxDateTime *arg1 = (wxDateTime *) 0 ;
22610 wxDateSpan *arg2 = 0 ;
22611 wxDateTime result;
22612 PyObject * obj0 = 0 ;
22613 PyObject * obj1 = 0 ;
22614
22615 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22617 if (SWIG_arg_fail(1)) SWIG_fail;
22618 {
22619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22620 if (SWIG_arg_fail(2)) SWIG_fail;
22621 if (arg2 == NULL) {
22622 SWIG_null_ref("wxDateSpan");
22623 }
22624 if (SWIG_arg_fail(2)) SWIG_fail;
22625 }
22626 {
22627 PyThreadState* __tstate = wxPyBeginAllowThreads();
22628 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22629
22630 wxPyEndAllowThreads(__tstate);
22631 if (PyErr_Occurred()) SWIG_fail;
22632 }
22633 {
22634 wxDateTime * resultptr;
22635 resultptr = new wxDateTime((wxDateTime &)(result));
22636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22637 }
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22645 int argc;
22646 PyObject *argv[3];
22647 int ii;
22648
22649 argc = PyObject_Length(args);
22650 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22651 argv[ii] = PyTuple_GetItem(args,ii);
22652 }
22653 if (argc == 2) {
22654 int _v;
22655 {
22656 void *ptr;
22657 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22658 _v = 0;
22659 PyErr_Clear();
22660 } else {
22661 _v = 1;
22662 }
22663 }
22664 if (_v) {
22665 {
22666 void *ptr = 0;
22667 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22668 _v = 0;
22669 PyErr_Clear();
22670 } else {
22671 _v = (ptr != 0);
22672 }
22673 }
22674 if (_v) {
22675 return _wrap_DateTime___sub____SWIG_0(self,args);
22676 }
22677 }
22678 }
22679 if (argc == 2) {
22680 int _v;
22681 {
22682 void *ptr;
22683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22684 _v = 0;
22685 PyErr_Clear();
22686 } else {
22687 _v = 1;
22688 }
22689 }
22690 if (_v) {
22691 {
22692 void *ptr = 0;
22693 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22694 _v = 0;
22695 PyErr_Clear();
22696 } else {
22697 _v = (ptr != 0);
22698 }
22699 }
22700 if (_v) {
22701 return _wrap_DateTime___sub____SWIG_1(self,args);
22702 }
22703 }
22704 }
22705 if (argc == 2) {
22706 int _v;
22707 {
22708 void *ptr;
22709 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22710 _v = 0;
22711 PyErr_Clear();
22712 } else {
22713 _v = 1;
22714 }
22715 }
22716 if (_v) {
22717 {
22718 void *ptr = 0;
22719 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22720 _v = 0;
22721 PyErr_Clear();
22722 } else {
22723 _v = (ptr != 0);
22724 }
22725 }
22726 if (_v) {
22727 return _wrap_DateTime___sub____SWIG_2(self,args);
22728 }
22729 }
22730 }
22731
22732 Py_INCREF(Py_NotImplemented);
22733 return Py_NotImplemented;
22734 }
22735
22736
22737 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22738 PyObject *resultobj;
22739 wxDateTime *arg1 = (wxDateTime *) 0 ;
22740 wxDateTime *arg2 = (wxDateTime *) 0 ;
22741 bool result;
22742 PyObject * obj0 = 0 ;
22743 PyObject * obj1 = 0 ;
22744 char *kwnames[] = {
22745 (char *) "self",(char *) "other", NULL
22746 };
22747
22748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(1)) SWIG_fail;
22751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22752 if (SWIG_arg_fail(2)) SWIG_fail;
22753 {
22754 PyThreadState* __tstate = wxPyBeginAllowThreads();
22755 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22756
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 {
22761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22762 }
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
22770 PyObject *resultobj;
22771 wxDateTime *arg1 = (wxDateTime *) 0 ;
22772 wxDateTime *arg2 = (wxDateTime *) 0 ;
22773 bool result;
22774 PyObject * obj0 = 0 ;
22775 PyObject * obj1 = 0 ;
22776 char *kwnames[] = {
22777 (char *) "self",(char *) "other", NULL
22778 };
22779
22780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
22781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22782 if (SWIG_arg_fail(1)) SWIG_fail;
22783 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22784 if (SWIG_arg_fail(2)) SWIG_fail;
22785 {
22786 PyThreadState* __tstate = wxPyBeginAllowThreads();
22787 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22788
22789 wxPyEndAllowThreads(__tstate);
22790 if (PyErr_Occurred()) SWIG_fail;
22791 }
22792 {
22793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22794 }
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
22802 PyObject *resultobj;
22803 wxDateTime *arg1 = (wxDateTime *) 0 ;
22804 wxDateTime *arg2 = (wxDateTime *) 0 ;
22805 bool result;
22806 PyObject * obj0 = 0 ;
22807 PyObject * obj1 = 0 ;
22808 char *kwnames[] = {
22809 (char *) "self",(char *) "other", NULL
22810 };
22811
22812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
22813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22814 if (SWIG_arg_fail(1)) SWIG_fail;
22815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22816 if (SWIG_arg_fail(2)) SWIG_fail;
22817 {
22818 PyThreadState* __tstate = wxPyBeginAllowThreads();
22819 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22820
22821 wxPyEndAllowThreads(__tstate);
22822 if (PyErr_Occurred()) SWIG_fail;
22823 }
22824 {
22825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22826 }
22827 return resultobj;
22828 fail:
22829 return NULL;
22830 }
22831
22832
22833 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
22834 PyObject *resultobj;
22835 wxDateTime *arg1 = (wxDateTime *) 0 ;
22836 wxDateTime *arg2 = (wxDateTime *) 0 ;
22837 bool result;
22838 PyObject * obj0 = 0 ;
22839 PyObject * obj1 = 0 ;
22840 char *kwnames[] = {
22841 (char *) "self",(char *) "other", NULL
22842 };
22843
22844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
22845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22846 if (SWIG_arg_fail(1)) SWIG_fail;
22847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22848 if (SWIG_arg_fail(2)) SWIG_fail;
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22852
22853 wxPyEndAllowThreads(__tstate);
22854 if (PyErr_Occurred()) SWIG_fail;
22855 }
22856 {
22857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22858 }
22859 return resultobj;
22860 fail:
22861 return NULL;
22862 }
22863
22864
22865 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
22866 PyObject *resultobj;
22867 wxDateTime *arg1 = (wxDateTime *) 0 ;
22868 wxDateTime *arg2 = (wxDateTime *) 0 ;
22869 bool result;
22870 PyObject * obj0 = 0 ;
22871 PyObject * obj1 = 0 ;
22872 char *kwnames[] = {
22873 (char *) "self",(char *) "other", NULL
22874 };
22875
22876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
22877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22878 if (SWIG_arg_fail(1)) SWIG_fail;
22879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(2)) SWIG_fail;
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22884
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 {
22889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22890 }
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
22898 PyObject *resultobj;
22899 wxDateTime *arg1 = (wxDateTime *) 0 ;
22900 wxDateTime *arg2 = (wxDateTime *) 0 ;
22901 bool result;
22902 PyObject * obj0 = 0 ;
22903 PyObject * obj1 = 0 ;
22904 char *kwnames[] = {
22905 (char *) "self",(char *) "other", NULL
22906 };
22907
22908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
22909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(1)) SWIG_fail;
22911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22912 if (SWIG_arg_fail(2)) SWIG_fail;
22913 {
22914 PyThreadState* __tstate = wxPyBeginAllowThreads();
22915 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22916
22917 wxPyEndAllowThreads(__tstate);
22918 if (PyErr_Occurred()) SWIG_fail;
22919 }
22920 {
22921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22922 }
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22930 PyObject *resultobj;
22931 wxDateTime *arg1 = (wxDateTime *) 0 ;
22932 wxString *arg2 = 0 ;
22933 int result;
22934 bool temp2 = false ;
22935 PyObject * obj0 = 0 ;
22936 PyObject * obj1 = 0 ;
22937 char *kwnames[] = {
22938 (char *) "self",(char *) "date", NULL
22939 };
22940
22941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22943 if (SWIG_arg_fail(1)) SWIG_fail;
22944 {
22945 arg2 = wxString_in_helper(obj1);
22946 if (arg2 == NULL) SWIG_fail;
22947 temp2 = true;
22948 }
22949 {
22950 PyThreadState* __tstate = wxPyBeginAllowThreads();
22951 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22952
22953 wxPyEndAllowThreads(__tstate);
22954 if (PyErr_Occurred()) SWIG_fail;
22955 }
22956 {
22957 resultobj = SWIG_From_int((int)(result));
22958 }
22959 {
22960 if (temp2)
22961 delete arg2;
22962 }
22963 return resultobj;
22964 fail:
22965 {
22966 if (temp2)
22967 delete arg2;
22968 }
22969 return NULL;
22970 }
22971
22972
22973 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22974 PyObject *resultobj;
22975 wxDateTime *arg1 = (wxDateTime *) 0 ;
22976 wxString *arg2 = 0 ;
22977 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22978 wxString *arg3 = (wxString *) &arg3_defvalue ;
22979 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22980 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22981 int result;
22982 bool temp2 = false ;
22983 bool temp3 = false ;
22984 PyObject * obj0 = 0 ;
22985 PyObject * obj1 = 0 ;
22986 PyObject * obj2 = 0 ;
22987 PyObject * obj3 = 0 ;
22988 char *kwnames[] = {
22989 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22990 };
22991
22992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22994 if (SWIG_arg_fail(1)) SWIG_fail;
22995 {
22996 arg2 = wxString_in_helper(obj1);
22997 if (arg2 == NULL) SWIG_fail;
22998 temp2 = true;
22999 }
23000 if (obj2) {
23001 {
23002 arg3 = wxString_in_helper(obj2);
23003 if (arg3 == NULL) SWIG_fail;
23004 temp3 = true;
23005 }
23006 }
23007 if (obj3) {
23008 {
23009 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23010 if (SWIG_arg_fail(4)) SWIG_fail;
23011 if (arg4 == NULL) {
23012 SWIG_null_ref("wxDateTime");
23013 }
23014 if (SWIG_arg_fail(4)) SWIG_fail;
23015 }
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 {
23025 resultobj = SWIG_From_int((int)(result));
23026 }
23027 {
23028 if (temp2)
23029 delete arg2;
23030 }
23031 {
23032 if (temp3)
23033 delete arg3;
23034 }
23035 return resultobj;
23036 fail:
23037 {
23038 if (temp2)
23039 delete arg2;
23040 }
23041 {
23042 if (temp3)
23043 delete arg3;
23044 }
23045 return NULL;
23046 }
23047
23048
23049 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23050 PyObject *resultobj;
23051 wxDateTime *arg1 = (wxDateTime *) 0 ;
23052 wxString *arg2 = 0 ;
23053 int result;
23054 bool temp2 = false ;
23055 PyObject * obj0 = 0 ;
23056 PyObject * obj1 = 0 ;
23057 char *kwnames[] = {
23058 (char *) "self",(char *) "datetime", NULL
23059 };
23060
23061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23063 if (SWIG_arg_fail(1)) SWIG_fail;
23064 {
23065 arg2 = wxString_in_helper(obj1);
23066 if (arg2 == NULL) SWIG_fail;
23067 temp2 = true;
23068 }
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23072
23073 wxPyEndAllowThreads(__tstate);
23074 if (PyErr_Occurred()) SWIG_fail;
23075 }
23076 {
23077 resultobj = SWIG_From_int((int)(result));
23078 }
23079 {
23080 if (temp2)
23081 delete arg2;
23082 }
23083 return resultobj;
23084 fail:
23085 {
23086 if (temp2)
23087 delete arg2;
23088 }
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxDateTime *arg1 = (wxDateTime *) 0 ;
23096 wxString *arg2 = 0 ;
23097 int result;
23098 bool temp2 = false ;
23099 PyObject * obj0 = 0 ;
23100 PyObject * obj1 = 0 ;
23101 char *kwnames[] = {
23102 (char *) "self",(char *) "date", NULL
23103 };
23104
23105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23107 if (SWIG_arg_fail(1)) SWIG_fail;
23108 {
23109 arg2 = wxString_in_helper(obj1);
23110 if (arg2 == NULL) SWIG_fail;
23111 temp2 = true;
23112 }
23113 {
23114 PyThreadState* __tstate = wxPyBeginAllowThreads();
23115 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23116
23117 wxPyEndAllowThreads(__tstate);
23118 if (PyErr_Occurred()) SWIG_fail;
23119 }
23120 {
23121 resultobj = SWIG_From_int((int)(result));
23122 }
23123 {
23124 if (temp2)
23125 delete arg2;
23126 }
23127 return resultobj;
23128 fail:
23129 {
23130 if (temp2)
23131 delete arg2;
23132 }
23133 return NULL;
23134 }
23135
23136
23137 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj;
23139 wxDateTime *arg1 = (wxDateTime *) 0 ;
23140 wxString *arg2 = 0 ;
23141 int result;
23142 bool temp2 = false ;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 char *kwnames[] = {
23146 (char *) "self",(char *) "time", NULL
23147 };
23148
23149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23151 if (SWIG_arg_fail(1)) SWIG_fail;
23152 {
23153 arg2 = wxString_in_helper(obj1);
23154 if (arg2 == NULL) SWIG_fail;
23155 temp2 = true;
23156 }
23157 {
23158 PyThreadState* __tstate = wxPyBeginAllowThreads();
23159 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23160
23161 wxPyEndAllowThreads(__tstate);
23162 if (PyErr_Occurred()) SWIG_fail;
23163 }
23164 {
23165 resultobj = SWIG_From_int((int)(result));
23166 }
23167 {
23168 if (temp2)
23169 delete arg2;
23170 }
23171 return resultobj;
23172 fail:
23173 {
23174 if (temp2)
23175 delete arg2;
23176 }
23177 return NULL;
23178 }
23179
23180
23181 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj;
23183 wxDateTime *arg1 = (wxDateTime *) 0 ;
23184 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23185 wxString *arg2 = (wxString *) &arg2_defvalue ;
23186 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23187 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23188 wxString result;
23189 bool temp2 = false ;
23190 bool temp3 = false ;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193 PyObject * obj2 = 0 ;
23194 char *kwnames[] = {
23195 (char *) "self",(char *) "format",(char *) "tz", NULL
23196 };
23197
23198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23200 if (SWIG_arg_fail(1)) SWIG_fail;
23201 if (obj1) {
23202 {
23203 arg2 = wxString_in_helper(obj1);
23204 if (arg2 == NULL) SWIG_fail;
23205 temp2 = true;
23206 }
23207 }
23208 if (obj2) {
23209 {
23210 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23211 temp3 = true;
23212 }
23213 }
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23217
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 {
23222 #if wxUSE_UNICODE
23223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23224 #else
23225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23226 #endif
23227 }
23228 {
23229 if (temp2)
23230 delete arg2;
23231 }
23232 {
23233 if (temp3) delete arg3;
23234 }
23235 return resultobj;
23236 fail:
23237 {
23238 if (temp2)
23239 delete arg2;
23240 }
23241 {
23242 if (temp3) delete arg3;
23243 }
23244 return NULL;
23245 }
23246
23247
23248 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23249 PyObject *resultobj;
23250 wxDateTime *arg1 = (wxDateTime *) 0 ;
23251 wxString result;
23252 PyObject * obj0 = 0 ;
23253 char *kwnames[] = {
23254 (char *) "self", NULL
23255 };
23256
23257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23259 if (SWIG_arg_fail(1)) SWIG_fail;
23260 {
23261 PyThreadState* __tstate = wxPyBeginAllowThreads();
23262 result = ((wxDateTime const *)arg1)->FormatDate();
23263
23264 wxPyEndAllowThreads(__tstate);
23265 if (PyErr_Occurred()) SWIG_fail;
23266 }
23267 {
23268 #if wxUSE_UNICODE
23269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23270 #else
23271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23272 #endif
23273 }
23274 return resultobj;
23275 fail:
23276 return NULL;
23277 }
23278
23279
23280 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23281 PyObject *resultobj;
23282 wxDateTime *arg1 = (wxDateTime *) 0 ;
23283 wxString result;
23284 PyObject * obj0 = 0 ;
23285 char *kwnames[] = {
23286 (char *) "self", NULL
23287 };
23288
23289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23291 if (SWIG_arg_fail(1)) SWIG_fail;
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = ((wxDateTime const *)arg1)->FormatTime();
23295
23296 wxPyEndAllowThreads(__tstate);
23297 if (PyErr_Occurred()) SWIG_fail;
23298 }
23299 {
23300 #if wxUSE_UNICODE
23301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23302 #else
23303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23304 #endif
23305 }
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj;
23314 wxDateTime *arg1 = (wxDateTime *) 0 ;
23315 wxString result;
23316 PyObject * obj0 = 0 ;
23317 char *kwnames[] = {
23318 (char *) "self", NULL
23319 };
23320
23321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23323 if (SWIG_arg_fail(1)) SWIG_fail;
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 result = ((wxDateTime const *)arg1)->FormatISODate();
23327
23328 wxPyEndAllowThreads(__tstate);
23329 if (PyErr_Occurred()) SWIG_fail;
23330 }
23331 {
23332 #if wxUSE_UNICODE
23333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23334 #else
23335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23336 #endif
23337 }
23338 return resultobj;
23339 fail:
23340 return NULL;
23341 }
23342
23343
23344 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23345 PyObject *resultobj;
23346 wxDateTime *arg1 = (wxDateTime *) 0 ;
23347 wxString result;
23348 PyObject * obj0 = 0 ;
23349 char *kwnames[] = {
23350 (char *) "self", NULL
23351 };
23352
23353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23355 if (SWIG_arg_fail(1)) SWIG_fail;
23356 {
23357 PyThreadState* __tstate = wxPyBeginAllowThreads();
23358 result = ((wxDateTime const *)arg1)->FormatISOTime();
23359
23360 wxPyEndAllowThreads(__tstate);
23361 if (PyErr_Occurred()) SWIG_fail;
23362 }
23363 {
23364 #if wxUSE_UNICODE
23365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23366 #else
23367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23368 #endif
23369 }
23370 return resultobj;
23371 fail:
23372 return NULL;
23373 }
23374
23375
23376 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23377 PyObject *obj;
23378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23379 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23380 Py_INCREF(obj);
23381 return Py_BuildValue((char *)"");
23382 }
23383 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 long arg1 ;
23386 wxTimeSpan result;
23387 PyObject * obj0 = 0 ;
23388 char *kwnames[] = {
23389 (char *) "sec", NULL
23390 };
23391
23392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23393 {
23394 arg1 = (long)(SWIG_As_long(obj0));
23395 if (SWIG_arg_fail(1)) SWIG_fail;
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = wxTimeSpan::Seconds(arg1);
23400
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 {
23405 wxTimeSpan * resultptr;
23406 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23407 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23408 }
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23416 PyObject *resultobj;
23417 wxTimeSpan result;
23418 char *kwnames[] = {
23419 NULL
23420 };
23421
23422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = wxTimeSpan::Second();
23426
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 {
23431 wxTimeSpan * resultptr;
23432 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23442 PyObject *resultobj;
23443 long arg1 ;
23444 wxTimeSpan result;
23445 PyObject * obj0 = 0 ;
23446 char *kwnames[] = {
23447 (char *) "min", NULL
23448 };
23449
23450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23451 {
23452 arg1 = (long)(SWIG_As_long(obj0));
23453 if (SWIG_arg_fail(1)) SWIG_fail;
23454 }
23455 {
23456 PyThreadState* __tstate = wxPyBeginAllowThreads();
23457 result = wxTimeSpan::Minutes(arg1);
23458
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 {
23463 wxTimeSpan * resultptr;
23464 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23466 }
23467 return resultobj;
23468 fail:
23469 return NULL;
23470 }
23471
23472
23473 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj;
23475 wxTimeSpan result;
23476 char *kwnames[] = {
23477 NULL
23478 };
23479
23480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23481 {
23482 PyThreadState* __tstate = wxPyBeginAllowThreads();
23483 result = wxTimeSpan::Minute();
23484
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 {
23489 wxTimeSpan * resultptr;
23490 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23492 }
23493 return resultobj;
23494 fail:
23495 return NULL;
23496 }
23497
23498
23499 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23500 PyObject *resultobj;
23501 long arg1 ;
23502 wxTimeSpan result;
23503 PyObject * obj0 = 0 ;
23504 char *kwnames[] = {
23505 (char *) "hours", NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23509 {
23510 arg1 = (long)(SWIG_As_long(obj0));
23511 if (SWIG_arg_fail(1)) SWIG_fail;
23512 }
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = wxTimeSpan::Hours(arg1);
23516
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 {
23521 wxTimeSpan * resultptr;
23522 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23523 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23524 }
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23532 PyObject *resultobj;
23533 wxTimeSpan result;
23534 char *kwnames[] = {
23535 NULL
23536 };
23537
23538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23539 {
23540 PyThreadState* __tstate = wxPyBeginAllowThreads();
23541 result = wxTimeSpan::Hour();
23542
23543 wxPyEndAllowThreads(__tstate);
23544 if (PyErr_Occurred()) SWIG_fail;
23545 }
23546 {
23547 wxTimeSpan * resultptr;
23548 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23550 }
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23558 PyObject *resultobj;
23559 long arg1 ;
23560 wxTimeSpan result;
23561 PyObject * obj0 = 0 ;
23562 char *kwnames[] = {
23563 (char *) "days", NULL
23564 };
23565
23566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23567 {
23568 arg1 = (long)(SWIG_As_long(obj0));
23569 if (SWIG_arg_fail(1)) SWIG_fail;
23570 }
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = wxTimeSpan::Days(arg1);
23574
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 wxTimeSpan * resultptr;
23580 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23582 }
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23590 PyObject *resultobj;
23591 wxTimeSpan result;
23592 char *kwnames[] = {
23593 NULL
23594 };
23595
23596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23597 {
23598 PyThreadState* __tstate = wxPyBeginAllowThreads();
23599 result = wxTimeSpan::Day();
23600
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 {
23605 wxTimeSpan * resultptr;
23606 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23608 }
23609 return resultobj;
23610 fail:
23611 return NULL;
23612 }
23613
23614
23615 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj;
23617 long arg1 ;
23618 wxTimeSpan result;
23619 PyObject * obj0 = 0 ;
23620 char *kwnames[] = {
23621 (char *) "days", NULL
23622 };
23623
23624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23625 {
23626 arg1 = (long)(SWIG_As_long(obj0));
23627 if (SWIG_arg_fail(1)) SWIG_fail;
23628 }
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = wxTimeSpan::Weeks(arg1);
23632
23633 wxPyEndAllowThreads(__tstate);
23634 if (PyErr_Occurred()) SWIG_fail;
23635 }
23636 {
23637 wxTimeSpan * resultptr;
23638 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23648 PyObject *resultobj;
23649 wxTimeSpan result;
23650 char *kwnames[] = {
23651 NULL
23652 };
23653
23654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 result = wxTimeSpan::Week();
23658
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 {
23663 wxTimeSpan * resultptr;
23664 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23666 }
23667 return resultobj;
23668 fail:
23669 return NULL;
23670 }
23671
23672
23673 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23674 PyObject *resultobj;
23675 long arg1 = (long) 0 ;
23676 long arg2 = (long) 0 ;
23677 long arg3 = (long) 0 ;
23678 long arg4 = (long) 0 ;
23679 wxTimeSpan *result;
23680 PyObject * obj0 = 0 ;
23681 PyObject * obj1 = 0 ;
23682 PyObject * obj2 = 0 ;
23683 PyObject * obj3 = 0 ;
23684 char *kwnames[] = {
23685 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23686 };
23687
23688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23689 if (obj0) {
23690 {
23691 arg1 = (long)(SWIG_As_long(obj0));
23692 if (SWIG_arg_fail(1)) SWIG_fail;
23693 }
23694 }
23695 if (obj1) {
23696 {
23697 arg2 = (long)(SWIG_As_long(obj1));
23698 if (SWIG_arg_fail(2)) SWIG_fail;
23699 }
23700 }
23701 if (obj2) {
23702 {
23703 arg3 = (long)(SWIG_As_long(obj2));
23704 if (SWIG_arg_fail(3)) SWIG_fail;
23705 }
23706 }
23707 if (obj3) {
23708 {
23709 arg4 = (long)(SWIG_As_long(obj3));
23710 if (SWIG_arg_fail(4)) SWIG_fail;
23711 }
23712 }
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23716
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj;
23729 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23730 PyObject * obj0 = 0 ;
23731 char *kwnames[] = {
23732 (char *) "self", NULL
23733 };
23734
23735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23737 if (SWIG_arg_fail(1)) SWIG_fail;
23738 {
23739 PyThreadState* __tstate = wxPyBeginAllowThreads();
23740 delete arg1;
23741
23742 wxPyEndAllowThreads(__tstate);
23743 if (PyErr_Occurred()) SWIG_fail;
23744 }
23745 Py_INCREF(Py_None); resultobj = Py_None;
23746 return resultobj;
23747 fail:
23748 return NULL;
23749 }
23750
23751
23752 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj;
23754 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23755 wxTimeSpan *arg2 = 0 ;
23756 wxTimeSpan *result;
23757 PyObject * obj0 = 0 ;
23758 PyObject * obj1 = 0 ;
23759 char *kwnames[] = {
23760 (char *) "self",(char *) "diff", NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 {
23767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23768 if (SWIG_arg_fail(2)) SWIG_fail;
23769 if (arg2 == NULL) {
23770 SWIG_null_ref("wxTimeSpan");
23771 }
23772 if (SWIG_arg_fail(2)) SWIG_fail;
23773 }
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 {
23777 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23778 result = (wxTimeSpan *) &_result_ref;
23779 }
23780
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23792 PyObject *resultobj;
23793 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23794 wxTimeSpan *arg2 = 0 ;
23795 wxTimeSpan *result;
23796 PyObject * obj0 = 0 ;
23797 PyObject * obj1 = 0 ;
23798 char *kwnames[] = {
23799 (char *) "self",(char *) "diff", NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 {
23806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23807 if (SWIG_arg_fail(2)) SWIG_fail;
23808 if (arg2 == NULL) {
23809 SWIG_null_ref("wxTimeSpan");
23810 }
23811 if (SWIG_arg_fail(2)) SWIG_fail;
23812 }
23813 {
23814 PyThreadState* __tstate = wxPyBeginAllowThreads();
23815 {
23816 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23817 result = (wxTimeSpan *) &_result_ref;
23818 }
23819
23820 wxPyEndAllowThreads(__tstate);
23821 if (PyErr_Occurred()) SWIG_fail;
23822 }
23823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23824 return resultobj;
23825 fail:
23826 return NULL;
23827 }
23828
23829
23830 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23831 PyObject *resultobj;
23832 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23833 int arg2 ;
23834 wxTimeSpan *result;
23835 PyObject * obj0 = 0 ;
23836 PyObject * obj1 = 0 ;
23837 char *kwnames[] = {
23838 (char *) "self",(char *) "n", NULL
23839 };
23840
23841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23843 if (SWIG_arg_fail(1)) SWIG_fail;
23844 {
23845 arg2 = (int)(SWIG_As_int(obj1));
23846 if (SWIG_arg_fail(2)) SWIG_fail;
23847 }
23848 {
23849 PyThreadState* __tstate = wxPyBeginAllowThreads();
23850 {
23851 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23852 result = (wxTimeSpan *) &_result_ref;
23853 }
23854
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23866 PyObject *resultobj;
23867 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23868 wxTimeSpan *result;
23869 PyObject * obj0 = 0 ;
23870 char *kwnames[] = {
23871 (char *) "self", NULL
23872 };
23873
23874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23876 if (SWIG_arg_fail(1)) SWIG_fail;
23877 {
23878 PyThreadState* __tstate = wxPyBeginAllowThreads();
23879 {
23880 wxTimeSpan &_result_ref = (arg1)->Neg();
23881 result = (wxTimeSpan *) &_result_ref;
23882 }
23883
23884 wxPyEndAllowThreads(__tstate);
23885 if (PyErr_Occurred()) SWIG_fail;
23886 }
23887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj;
23896 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23897 wxTimeSpan result;
23898 PyObject * obj0 = 0 ;
23899 char *kwnames[] = {
23900 (char *) "self", NULL
23901 };
23902
23903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23905 if (SWIG_arg_fail(1)) SWIG_fail;
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 result = ((wxTimeSpan const *)arg1)->Abs();
23909
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 {
23914 wxTimeSpan * resultptr;
23915 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23917 }
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23925 PyObject *resultobj;
23926 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23927 wxTimeSpan *arg2 = 0 ;
23928 wxTimeSpan *result;
23929 PyObject * obj0 = 0 ;
23930 PyObject * obj1 = 0 ;
23931 char *kwnames[] = {
23932 (char *) "self",(char *) "diff", NULL
23933 };
23934
23935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23937 if (SWIG_arg_fail(1)) SWIG_fail;
23938 {
23939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23940 if (SWIG_arg_fail(2)) SWIG_fail;
23941 if (arg2 == NULL) {
23942 SWIG_null_ref("wxTimeSpan");
23943 }
23944 if (SWIG_arg_fail(2)) SWIG_fail;
23945 }
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 {
23949 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23950 result = (wxTimeSpan *) &_result_ref;
23951 }
23952
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23964 PyObject *resultobj;
23965 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23966 wxTimeSpan *arg2 = 0 ;
23967 wxTimeSpan *result;
23968 PyObject * obj0 = 0 ;
23969 PyObject * obj1 = 0 ;
23970 char *kwnames[] = {
23971 (char *) "self",(char *) "diff", NULL
23972 };
23973
23974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23976 if (SWIG_arg_fail(1)) SWIG_fail;
23977 {
23978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23979 if (SWIG_arg_fail(2)) SWIG_fail;
23980 if (arg2 == NULL) {
23981 SWIG_null_ref("wxTimeSpan");
23982 }
23983 if (SWIG_arg_fail(2)) SWIG_fail;
23984 }
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 {
23988 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23989 result = (wxTimeSpan *) &_result_ref;
23990 }
23991
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23996 return resultobj;
23997 fail:
23998 return NULL;
23999 }
24000
24001
24002 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24003 PyObject *resultobj;
24004 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24005 int arg2 ;
24006 wxTimeSpan *result;
24007 PyObject * obj0 = 0 ;
24008 PyObject * obj1 = 0 ;
24009 char *kwnames[] = {
24010 (char *) "self",(char *) "n", NULL
24011 };
24012
24013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24015 if (SWIG_arg_fail(1)) SWIG_fail;
24016 {
24017 arg2 = (int)(SWIG_As_int(obj1));
24018 if (SWIG_arg_fail(2)) SWIG_fail;
24019 }
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 {
24023 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24024 result = (wxTimeSpan *) &_result_ref;
24025 }
24026
24027 wxPyEndAllowThreads(__tstate);
24028 if (PyErr_Occurred()) SWIG_fail;
24029 }
24030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24038 PyObject *resultobj;
24039 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24040 wxTimeSpan *result;
24041 PyObject * obj0 = 0 ;
24042 char *kwnames[] = {
24043 (char *) "self", NULL
24044 };
24045
24046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 {
24052 wxTimeSpan &_result_ref = (arg1)->operator -();
24053 result = (wxTimeSpan *) &_result_ref;
24054 }
24055
24056 wxPyEndAllowThreads(__tstate);
24057 if (PyErr_Occurred()) SWIG_fail;
24058 }
24059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24060 return resultobj;
24061 fail:
24062 return NULL;
24063 }
24064
24065
24066 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24067 PyObject *resultobj;
24068 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24069 wxTimeSpan *arg2 = 0 ;
24070 wxTimeSpan result;
24071 PyObject * obj0 = 0 ;
24072 PyObject * obj1 = 0 ;
24073 char *kwnames[] = {
24074 (char *) "self",(char *) "other", NULL
24075 };
24076
24077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(1)) SWIG_fail;
24080 {
24081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24082 if (SWIG_arg_fail(2)) SWIG_fail;
24083 if (arg2 == NULL) {
24084 SWIG_null_ref("wxTimeSpan");
24085 }
24086 if (SWIG_arg_fail(2)) SWIG_fail;
24087 }
24088 {
24089 PyThreadState* __tstate = wxPyBeginAllowThreads();
24090 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24091
24092 wxPyEndAllowThreads(__tstate);
24093 if (PyErr_Occurred()) SWIG_fail;
24094 }
24095 {
24096 wxTimeSpan * resultptr;
24097 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24098 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24099 }
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24107 PyObject *resultobj;
24108 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24109 wxTimeSpan *arg2 = 0 ;
24110 wxTimeSpan result;
24111 PyObject * obj0 = 0 ;
24112 PyObject * obj1 = 0 ;
24113 char *kwnames[] = {
24114 (char *) "self",(char *) "other", NULL
24115 };
24116
24117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24119 if (SWIG_arg_fail(1)) SWIG_fail;
24120 {
24121 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24122 if (SWIG_arg_fail(2)) SWIG_fail;
24123 if (arg2 == NULL) {
24124 SWIG_null_ref("wxTimeSpan");
24125 }
24126 if (SWIG_arg_fail(2)) SWIG_fail;
24127 }
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24131
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 {
24136 wxTimeSpan * resultptr;
24137 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24139 }
24140 return resultobj;
24141 fail:
24142 return NULL;
24143 }
24144
24145
24146 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24147 PyObject *resultobj;
24148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24149 int arg2 ;
24150 wxTimeSpan result;
24151 PyObject * obj0 = 0 ;
24152 PyObject * obj1 = 0 ;
24153 char *kwnames[] = {
24154 (char *) "self",(char *) "n", NULL
24155 };
24156
24157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24159 if (SWIG_arg_fail(1)) SWIG_fail;
24160 {
24161 arg2 = (int)(SWIG_As_int(obj1));
24162 if (SWIG_arg_fail(2)) SWIG_fail;
24163 }
24164 {
24165 PyThreadState* __tstate = wxPyBeginAllowThreads();
24166 result = wxTimeSpan___mul__(arg1,arg2);
24167
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 {
24172 wxTimeSpan * resultptr;
24173 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24175 }
24176 return resultobj;
24177 fail:
24178 return NULL;
24179 }
24180
24181
24182 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj;
24184 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24185 int arg2 ;
24186 wxTimeSpan result;
24187 PyObject * obj0 = 0 ;
24188 PyObject * obj1 = 0 ;
24189 char *kwnames[] = {
24190 (char *) "self",(char *) "n", NULL
24191 };
24192
24193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24195 if (SWIG_arg_fail(1)) SWIG_fail;
24196 {
24197 arg2 = (int)(SWIG_As_int(obj1));
24198 if (SWIG_arg_fail(2)) SWIG_fail;
24199 }
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = wxTimeSpan___rmul__(arg1,arg2);
24203
24204 wxPyEndAllowThreads(__tstate);
24205 if (PyErr_Occurred()) SWIG_fail;
24206 }
24207 {
24208 wxTimeSpan * resultptr;
24209 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24210 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24211 }
24212 return resultobj;
24213 fail:
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24221 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24222 bool result;
24223 PyObject * obj0 = 0 ;
24224 PyObject * obj1 = 0 ;
24225 char *kwnames[] = {
24226 (char *) "self",(char *) "other", NULL
24227 };
24228
24229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24231 if (SWIG_arg_fail(1)) SWIG_fail;
24232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24233 if (SWIG_arg_fail(2)) SWIG_fail;
24234 {
24235 PyThreadState* __tstate = wxPyBeginAllowThreads();
24236 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24237
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 {
24242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24243 }
24244 return resultobj;
24245 fail:
24246 return NULL;
24247 }
24248
24249
24250 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24251 PyObject *resultobj;
24252 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24253 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24254 bool result;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self",(char *) "other", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24265 if (SWIG_arg_fail(2)) SWIG_fail;
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24269
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 {
24274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24275 }
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24283 PyObject *resultobj;
24284 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24285 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24286 bool result;
24287 PyObject * obj0 = 0 ;
24288 PyObject * obj1 = 0 ;
24289 char *kwnames[] = {
24290 (char *) "self",(char *) "other", NULL
24291 };
24292
24293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24295 if (SWIG_arg_fail(1)) SWIG_fail;
24296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24297 if (SWIG_arg_fail(2)) SWIG_fail;
24298 {
24299 PyThreadState* __tstate = wxPyBeginAllowThreads();
24300 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24301
24302 wxPyEndAllowThreads(__tstate);
24303 if (PyErr_Occurred()) SWIG_fail;
24304 }
24305 {
24306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24307 }
24308 return resultobj;
24309 fail:
24310 return NULL;
24311 }
24312
24313
24314 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj;
24316 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24317 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24318 bool result;
24319 PyObject * obj0 = 0 ;
24320 PyObject * obj1 = 0 ;
24321 char *kwnames[] = {
24322 (char *) "self",(char *) "other", NULL
24323 };
24324
24325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24327 if (SWIG_arg_fail(1)) SWIG_fail;
24328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24329 if (SWIG_arg_fail(2)) SWIG_fail;
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24333
24334 wxPyEndAllowThreads(__tstate);
24335 if (PyErr_Occurred()) SWIG_fail;
24336 }
24337 {
24338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24339 }
24340 return resultobj;
24341 fail:
24342 return NULL;
24343 }
24344
24345
24346 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24347 PyObject *resultobj;
24348 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24349 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24350 bool result;
24351 PyObject * obj0 = 0 ;
24352 PyObject * obj1 = 0 ;
24353 char *kwnames[] = {
24354 (char *) "self",(char *) "other", NULL
24355 };
24356
24357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24359 if (SWIG_arg_fail(1)) SWIG_fail;
24360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24361 if (SWIG_arg_fail(2)) SWIG_fail;
24362 {
24363 PyThreadState* __tstate = wxPyBeginAllowThreads();
24364 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24365
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 {
24370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24371 }
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj;
24380 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24381 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24382 bool result;
24383 PyObject * obj0 = 0 ;
24384 PyObject * obj1 = 0 ;
24385 char *kwnames[] = {
24386 (char *) "self",(char *) "other", NULL
24387 };
24388
24389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24393 if (SWIG_arg_fail(2)) SWIG_fail;
24394 {
24395 PyThreadState* __tstate = wxPyBeginAllowThreads();
24396 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24397
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 {
24402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24403 }
24404 return resultobj;
24405 fail:
24406 return NULL;
24407 }
24408
24409
24410 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24411 PyObject *resultobj;
24412 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24413 bool result;
24414 PyObject * obj0 = 0 ;
24415 char *kwnames[] = {
24416 (char *) "self", NULL
24417 };
24418
24419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24421 if (SWIG_arg_fail(1)) SWIG_fail;
24422 {
24423 PyThreadState* __tstate = wxPyBeginAllowThreads();
24424 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24425
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 {
24430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24431 }
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj;
24440 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24441 bool result;
24442 PyObject * obj0 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "self", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24449 if (SWIG_arg_fail(1)) SWIG_fail;
24450 {
24451 PyThreadState* __tstate = wxPyBeginAllowThreads();
24452 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24453
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 {
24458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24459 }
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24467 PyObject *resultobj;
24468 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24469 bool result;
24470 PyObject * obj0 = 0 ;
24471 char *kwnames[] = {
24472 (char *) "self", NULL
24473 };
24474
24475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
24480 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24481
24482 wxPyEndAllowThreads(__tstate);
24483 if (PyErr_Occurred()) SWIG_fail;
24484 }
24485 {
24486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24487 }
24488 return resultobj;
24489 fail:
24490 return NULL;
24491 }
24492
24493
24494 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24495 PyObject *resultobj;
24496 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24497 wxTimeSpan *arg2 = 0 ;
24498 bool result;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 char *kwnames[] = {
24502 (char *) "self",(char *) "ts", NULL
24503 };
24504
24505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24507 if (SWIG_arg_fail(1)) SWIG_fail;
24508 {
24509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24510 if (SWIG_arg_fail(2)) SWIG_fail;
24511 if (arg2 == NULL) {
24512 SWIG_null_ref("wxTimeSpan");
24513 }
24514 if (SWIG_arg_fail(2)) SWIG_fail;
24515 }
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24519
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 {
24524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24525 }
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24533 PyObject *resultobj;
24534 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24535 wxTimeSpan *arg2 = 0 ;
24536 bool result;
24537 PyObject * obj0 = 0 ;
24538 PyObject * obj1 = 0 ;
24539 char *kwnames[] = {
24540 (char *) "self",(char *) "ts", NULL
24541 };
24542
24543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24545 if (SWIG_arg_fail(1)) SWIG_fail;
24546 {
24547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24548 if (SWIG_arg_fail(2)) SWIG_fail;
24549 if (arg2 == NULL) {
24550 SWIG_null_ref("wxTimeSpan");
24551 }
24552 if (SWIG_arg_fail(2)) SWIG_fail;
24553 }
24554 {
24555 PyThreadState* __tstate = wxPyBeginAllowThreads();
24556 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24557
24558 wxPyEndAllowThreads(__tstate);
24559 if (PyErr_Occurred()) SWIG_fail;
24560 }
24561 {
24562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24563 }
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj;
24572 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24573 wxTimeSpan *arg2 = 0 ;
24574 bool result;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char *kwnames[] = {
24578 (char *) "self",(char *) "t", NULL
24579 };
24580
24581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24583 if (SWIG_arg_fail(1)) SWIG_fail;
24584 {
24585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24586 if (SWIG_arg_fail(2)) SWIG_fail;
24587 if (arg2 == NULL) {
24588 SWIG_null_ref("wxTimeSpan");
24589 }
24590 if (SWIG_arg_fail(2)) SWIG_fail;
24591 }
24592 {
24593 PyThreadState* __tstate = wxPyBeginAllowThreads();
24594 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24595
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 {
24600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24601 }
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj;
24610 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24611 int result;
24612 PyObject * obj0 = 0 ;
24613 char *kwnames[] = {
24614 (char *) "self", NULL
24615 };
24616
24617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24619 if (SWIG_arg_fail(1)) SWIG_fail;
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24623
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 {
24628 resultobj = SWIG_From_int((int)(result));
24629 }
24630 return resultobj;
24631 fail:
24632 return NULL;
24633 }
24634
24635
24636 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24637 PyObject *resultobj;
24638 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24639 int result;
24640 PyObject * obj0 = 0 ;
24641 char *kwnames[] = {
24642 (char *) "self", NULL
24643 };
24644
24645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24647 if (SWIG_arg_fail(1)) SWIG_fail;
24648 {
24649 PyThreadState* __tstate = wxPyBeginAllowThreads();
24650 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24651
24652 wxPyEndAllowThreads(__tstate);
24653 if (PyErr_Occurred()) SWIG_fail;
24654 }
24655 {
24656 resultobj = SWIG_From_int((int)(result));
24657 }
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24665 PyObject *resultobj;
24666 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24667 int result;
24668 PyObject * obj0 = 0 ;
24669 char *kwnames[] = {
24670 (char *) "self", NULL
24671 };
24672
24673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24675 if (SWIG_arg_fail(1)) SWIG_fail;
24676 {
24677 PyThreadState* __tstate = wxPyBeginAllowThreads();
24678 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24679
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 resultobj = SWIG_From_int((int)(result));
24685 }
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24693 PyObject *resultobj;
24694 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24695 int result;
24696 PyObject * obj0 = 0 ;
24697 char *kwnames[] = {
24698 (char *) "self", NULL
24699 };
24700
24701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24703 if (SWIG_arg_fail(1)) SWIG_fail;
24704 {
24705 PyThreadState* __tstate = wxPyBeginAllowThreads();
24706 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24707
24708 wxPyEndAllowThreads(__tstate);
24709 if (PyErr_Occurred()) SWIG_fail;
24710 }
24711 {
24712 resultobj = SWIG_From_int((int)(result));
24713 }
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj;
24722 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24723 wxLongLong result;
24724 PyObject * obj0 = 0 ;
24725 char *kwnames[] = {
24726 (char *) "self", NULL
24727 };
24728
24729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24731 if (SWIG_arg_fail(1)) SWIG_fail;
24732 {
24733 PyThreadState* __tstate = wxPyBeginAllowThreads();
24734 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24735
24736 wxPyEndAllowThreads(__tstate);
24737 if (PyErr_Occurred()) SWIG_fail;
24738 }
24739 {
24740 PyObject *hi, *lo, *shifter, *shifted;
24741 hi = PyLong_FromLong( (&result)->GetHi() );
24742 lo = PyLong_FromLong( (&result)->GetLo() );
24743 shifter = PyLong_FromLong(32);
24744 shifted = PyNumber_Lshift(hi, shifter);
24745 resultobj = PyNumber_Or(shifted, lo);
24746 Py_DECREF(hi);
24747 Py_DECREF(lo);
24748 Py_DECREF(shifter);
24749 Py_DECREF(shifted);
24750 }
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24758 PyObject *resultobj;
24759 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24760 wxLongLong result;
24761 PyObject * obj0 = 0 ;
24762 char *kwnames[] = {
24763 (char *) "self", NULL
24764 };
24765
24766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24768 if (SWIG_arg_fail(1)) SWIG_fail;
24769 {
24770 PyThreadState* __tstate = wxPyBeginAllowThreads();
24771 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24772
24773 wxPyEndAllowThreads(__tstate);
24774 if (PyErr_Occurred()) SWIG_fail;
24775 }
24776 {
24777 PyObject *hi, *lo, *shifter, *shifted;
24778 hi = PyLong_FromLong( (&result)->GetHi() );
24779 lo = PyLong_FromLong( (&result)->GetLo() );
24780 shifter = PyLong_FromLong(32);
24781 shifted = PyNumber_Lshift(hi, shifter);
24782 resultobj = PyNumber_Or(shifted, lo);
24783 Py_DECREF(hi);
24784 Py_DECREF(lo);
24785 Py_DECREF(shifter);
24786 Py_DECREF(shifted);
24787 }
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj;
24796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24797 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24798 wxString *arg2 = (wxString *) &arg2_defvalue ;
24799 wxString result;
24800 bool temp2 = false ;
24801 PyObject * obj0 = 0 ;
24802 PyObject * obj1 = 0 ;
24803 char *kwnames[] = {
24804 (char *) "self",(char *) "format", NULL
24805 };
24806
24807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24809 if (SWIG_arg_fail(1)) SWIG_fail;
24810 if (obj1) {
24811 {
24812 arg2 = wxString_in_helper(obj1);
24813 if (arg2 == NULL) SWIG_fail;
24814 temp2 = true;
24815 }
24816 }
24817 {
24818 PyThreadState* __tstate = wxPyBeginAllowThreads();
24819 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24820
24821 wxPyEndAllowThreads(__tstate);
24822 if (PyErr_Occurred()) SWIG_fail;
24823 }
24824 {
24825 #if wxUSE_UNICODE
24826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24827 #else
24828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24829 #endif
24830 }
24831 {
24832 if (temp2)
24833 delete arg2;
24834 }
24835 return resultobj;
24836 fail:
24837 {
24838 if (temp2)
24839 delete arg2;
24840 }
24841 return NULL;
24842 }
24843
24844
24845 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24846 PyObject *obj;
24847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24848 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24849 Py_INCREF(obj);
24850 return Py_BuildValue((char *)"");
24851 }
24852 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj;
24854 int arg1 = (int) 0 ;
24855 int arg2 = (int) 0 ;
24856 int arg3 = (int) 0 ;
24857 int arg4 = (int) 0 ;
24858 wxDateSpan *result;
24859 PyObject * obj0 = 0 ;
24860 PyObject * obj1 = 0 ;
24861 PyObject * obj2 = 0 ;
24862 PyObject * obj3 = 0 ;
24863 char *kwnames[] = {
24864 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24868 if (obj0) {
24869 {
24870 arg1 = (int)(SWIG_As_int(obj0));
24871 if (SWIG_arg_fail(1)) SWIG_fail;
24872 }
24873 }
24874 if (obj1) {
24875 {
24876 arg2 = (int)(SWIG_As_int(obj1));
24877 if (SWIG_arg_fail(2)) SWIG_fail;
24878 }
24879 }
24880 if (obj2) {
24881 {
24882 arg3 = (int)(SWIG_As_int(obj2));
24883 if (SWIG_arg_fail(3)) SWIG_fail;
24884 }
24885 }
24886 if (obj3) {
24887 {
24888 arg4 = (int)(SWIG_As_int(obj3));
24889 if (SWIG_arg_fail(4)) SWIG_fail;
24890 }
24891 }
24892 {
24893 PyThreadState* __tstate = wxPyBeginAllowThreads();
24894 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24895
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj;
24908 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24909 PyObject * obj0 = 0 ;
24910 char *kwnames[] = {
24911 (char *) "self", NULL
24912 };
24913
24914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24916 if (SWIG_arg_fail(1)) SWIG_fail;
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 delete arg1;
24920
24921 wxPyEndAllowThreads(__tstate);
24922 if (PyErr_Occurred()) SWIG_fail;
24923 }
24924 Py_INCREF(Py_None); resultobj = Py_None;
24925 return resultobj;
24926 fail:
24927 return NULL;
24928 }
24929
24930
24931 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24932 PyObject *resultobj;
24933 int arg1 ;
24934 wxDateSpan result;
24935 PyObject * obj0 = 0 ;
24936 char *kwnames[] = {
24937 (char *) "days", NULL
24938 };
24939
24940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24941 {
24942 arg1 = (int)(SWIG_As_int(obj0));
24943 if (SWIG_arg_fail(1)) SWIG_fail;
24944 }
24945 {
24946 PyThreadState* __tstate = wxPyBeginAllowThreads();
24947 result = wxDateSpan::Days(arg1);
24948
24949 wxPyEndAllowThreads(__tstate);
24950 if (PyErr_Occurred()) SWIG_fail;
24951 }
24952 {
24953 wxDateSpan * resultptr;
24954 resultptr = new wxDateSpan((wxDateSpan &)(result));
24955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24956 }
24957 return resultobj;
24958 fail:
24959 return NULL;
24960 }
24961
24962
24963 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj;
24965 wxDateSpan result;
24966 char *kwnames[] = {
24967 NULL
24968 };
24969
24970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24971 {
24972 PyThreadState* __tstate = wxPyBeginAllowThreads();
24973 result = wxDateSpan::Day();
24974
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 wxDateSpan * resultptr;
24980 resultptr = new wxDateSpan((wxDateSpan &)(result));
24981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24982 }
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24990 PyObject *resultobj;
24991 int arg1 ;
24992 wxDateSpan result;
24993 PyObject * obj0 = 0 ;
24994 char *kwnames[] = {
24995 (char *) "weeks", NULL
24996 };
24997
24998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
24999 {
25000 arg1 = (int)(SWIG_As_int(obj0));
25001 if (SWIG_arg_fail(1)) SWIG_fail;
25002 }
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = wxDateSpan::Weeks(arg1);
25006
25007 wxPyEndAllowThreads(__tstate);
25008 if (PyErr_Occurred()) SWIG_fail;
25009 }
25010 {
25011 wxDateSpan * resultptr;
25012 resultptr = new wxDateSpan((wxDateSpan &)(result));
25013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25014 }
25015 return resultobj;
25016 fail:
25017 return NULL;
25018 }
25019
25020
25021 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25022 PyObject *resultobj;
25023 wxDateSpan result;
25024 char *kwnames[] = {
25025 NULL
25026 };
25027
25028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 result = wxDateSpan::Week();
25032
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 {
25037 wxDateSpan * resultptr;
25038 resultptr = new wxDateSpan((wxDateSpan &)(result));
25039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25040 }
25041 return resultobj;
25042 fail:
25043 return NULL;
25044 }
25045
25046
25047 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25048 PyObject *resultobj;
25049 int arg1 ;
25050 wxDateSpan result;
25051 PyObject * obj0 = 0 ;
25052 char *kwnames[] = {
25053 (char *) "mon", NULL
25054 };
25055
25056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25057 {
25058 arg1 = (int)(SWIG_As_int(obj0));
25059 if (SWIG_arg_fail(1)) SWIG_fail;
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = wxDateSpan::Months(arg1);
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 wxDateSpan * resultptr;
25070 resultptr = new wxDateSpan((wxDateSpan &)(result));
25071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25080 PyObject *resultobj;
25081 wxDateSpan result;
25082 char *kwnames[] = {
25083 NULL
25084 };
25085
25086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = wxDateSpan::Month();
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 wxDateSpan * resultptr;
25096 resultptr = new wxDateSpan((wxDateSpan &)(result));
25097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25106 PyObject *resultobj;
25107 int arg1 ;
25108 wxDateSpan result;
25109 PyObject * obj0 = 0 ;
25110 char *kwnames[] = {
25111 (char *) "years", NULL
25112 };
25113
25114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25115 {
25116 arg1 = (int)(SWIG_As_int(obj0));
25117 if (SWIG_arg_fail(1)) SWIG_fail;
25118 }
25119 {
25120 PyThreadState* __tstate = wxPyBeginAllowThreads();
25121 result = wxDateSpan::Years(arg1);
25122
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 {
25127 wxDateSpan * resultptr;
25128 resultptr = new wxDateSpan((wxDateSpan &)(result));
25129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25130 }
25131 return resultobj;
25132 fail:
25133 return NULL;
25134 }
25135
25136
25137 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25138 PyObject *resultobj;
25139 wxDateSpan result;
25140 char *kwnames[] = {
25141 NULL
25142 };
25143
25144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = wxDateSpan::Year();
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 wxDateSpan * resultptr;
25154 resultptr = new wxDateSpan((wxDateSpan &)(result));
25155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25156 }
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj;
25165 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25166 int arg2 ;
25167 wxDateSpan *result;
25168 PyObject * obj0 = 0 ;
25169 PyObject * obj1 = 0 ;
25170 char *kwnames[] = {
25171 (char *) "self",(char *) "n", NULL
25172 };
25173
25174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25176 if (SWIG_arg_fail(1)) SWIG_fail;
25177 {
25178 arg2 = (int)(SWIG_As_int(obj1));
25179 if (SWIG_arg_fail(2)) SWIG_fail;
25180 }
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 {
25184 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25185 result = (wxDateSpan *) &_result_ref;
25186 }
25187
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25201 int arg2 ;
25202 wxDateSpan *result;
25203 PyObject * obj0 = 0 ;
25204 PyObject * obj1 = 0 ;
25205 char *kwnames[] = {
25206 (char *) "self",(char *) "n", NULL
25207 };
25208
25209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25211 if (SWIG_arg_fail(1)) SWIG_fail;
25212 {
25213 arg2 = (int)(SWIG_As_int(obj1));
25214 if (SWIG_arg_fail(2)) SWIG_fail;
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 {
25219 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25220 result = (wxDateSpan *) &_result_ref;
25221 }
25222
25223 wxPyEndAllowThreads(__tstate);
25224 if (PyErr_Occurred()) SWIG_fail;
25225 }
25226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25227 return resultobj;
25228 fail:
25229 return NULL;
25230 }
25231
25232
25233 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25234 PyObject *resultobj;
25235 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25236 int arg2 ;
25237 wxDateSpan *result;
25238 PyObject * obj0 = 0 ;
25239 PyObject * obj1 = 0 ;
25240 char *kwnames[] = {
25241 (char *) "self",(char *) "n", NULL
25242 };
25243
25244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25246 if (SWIG_arg_fail(1)) SWIG_fail;
25247 {
25248 arg2 = (int)(SWIG_As_int(obj1));
25249 if (SWIG_arg_fail(2)) SWIG_fail;
25250 }
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 {
25254 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25255 result = (wxDateSpan *) &_result_ref;
25256 }
25257
25258 wxPyEndAllowThreads(__tstate);
25259 if (PyErr_Occurred()) SWIG_fail;
25260 }
25261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25262 return resultobj;
25263 fail:
25264 return NULL;
25265 }
25266
25267
25268 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj;
25270 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25271 int arg2 ;
25272 wxDateSpan *result;
25273 PyObject * obj0 = 0 ;
25274 PyObject * obj1 = 0 ;
25275 char *kwnames[] = {
25276 (char *) "self",(char *) "n", NULL
25277 };
25278
25279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25281 if (SWIG_arg_fail(1)) SWIG_fail;
25282 {
25283 arg2 = (int)(SWIG_As_int(obj1));
25284 if (SWIG_arg_fail(2)) SWIG_fail;
25285 }
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 {
25289 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25290 result = (wxDateSpan *) &_result_ref;
25291 }
25292
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25297 return resultobj;
25298 fail:
25299 return NULL;
25300 }
25301
25302
25303 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25304 PyObject *resultobj;
25305 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25306 int result;
25307 PyObject * obj0 = 0 ;
25308 char *kwnames[] = {
25309 (char *) "self", NULL
25310 };
25311
25312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25314 if (SWIG_arg_fail(1)) SWIG_fail;
25315 {
25316 PyThreadState* __tstate = wxPyBeginAllowThreads();
25317 result = (int)((wxDateSpan const *)arg1)->GetYears();
25318
25319 wxPyEndAllowThreads(__tstate);
25320 if (PyErr_Occurred()) SWIG_fail;
25321 }
25322 {
25323 resultobj = SWIG_From_int((int)(result));
25324 }
25325 return resultobj;
25326 fail:
25327 return NULL;
25328 }
25329
25330
25331 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25332 PyObject *resultobj;
25333 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25334 int result;
25335 PyObject * obj0 = 0 ;
25336 char *kwnames[] = {
25337 (char *) "self", NULL
25338 };
25339
25340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25342 if (SWIG_arg_fail(1)) SWIG_fail;
25343 {
25344 PyThreadState* __tstate = wxPyBeginAllowThreads();
25345 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25346
25347 wxPyEndAllowThreads(__tstate);
25348 if (PyErr_Occurred()) SWIG_fail;
25349 }
25350 {
25351 resultobj = SWIG_From_int((int)(result));
25352 }
25353 return resultobj;
25354 fail:
25355 return NULL;
25356 }
25357
25358
25359 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25360 PyObject *resultobj;
25361 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25362 int result;
25363 PyObject * obj0 = 0 ;
25364 char *kwnames[] = {
25365 (char *) "self", NULL
25366 };
25367
25368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25370 if (SWIG_arg_fail(1)) SWIG_fail;
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25374
25375 wxPyEndAllowThreads(__tstate);
25376 if (PyErr_Occurred()) SWIG_fail;
25377 }
25378 {
25379 resultobj = SWIG_From_int((int)(result));
25380 }
25381 return resultobj;
25382 fail:
25383 return NULL;
25384 }
25385
25386
25387 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25388 PyObject *resultobj;
25389 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25390 int result;
25391 PyObject * obj0 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "self", NULL
25394 };
25395
25396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25398 if (SWIG_arg_fail(1)) SWIG_fail;
25399 {
25400 PyThreadState* __tstate = wxPyBeginAllowThreads();
25401 result = (int)((wxDateSpan const *)arg1)->GetDays();
25402
25403 wxPyEndAllowThreads(__tstate);
25404 if (PyErr_Occurred()) SWIG_fail;
25405 }
25406 {
25407 resultobj = SWIG_From_int((int)(result));
25408 }
25409 return resultobj;
25410 fail:
25411 return NULL;
25412 }
25413
25414
25415 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25416 PyObject *resultobj;
25417 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25418 int result;
25419 PyObject * obj0 = 0 ;
25420 char *kwnames[] = {
25421 (char *) "self", NULL
25422 };
25423
25424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25430
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 {
25435 resultobj = SWIG_From_int((int)(result));
25436 }
25437 return resultobj;
25438 fail:
25439 return NULL;
25440 }
25441
25442
25443 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25444 PyObject *resultobj;
25445 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25446 wxDateSpan *arg2 = 0 ;
25447 wxDateSpan *result;
25448 PyObject * obj0 = 0 ;
25449 PyObject * obj1 = 0 ;
25450 char *kwnames[] = {
25451 (char *) "self",(char *) "other", NULL
25452 };
25453
25454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25456 if (SWIG_arg_fail(1)) SWIG_fail;
25457 {
25458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25459 if (SWIG_arg_fail(2)) SWIG_fail;
25460 if (arg2 == NULL) {
25461 SWIG_null_ref("wxDateSpan");
25462 }
25463 if (SWIG_arg_fail(2)) SWIG_fail;
25464 }
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 {
25468 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25469 result = (wxDateSpan *) &_result_ref;
25470 }
25471
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj;
25484 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25485 wxDateSpan *arg2 = 0 ;
25486 wxDateSpan *result;
25487 PyObject * obj0 = 0 ;
25488 PyObject * obj1 = 0 ;
25489 char *kwnames[] = {
25490 (char *) "self",(char *) "other", NULL
25491 };
25492
25493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25495 if (SWIG_arg_fail(1)) SWIG_fail;
25496 {
25497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25498 if (SWIG_arg_fail(2)) SWIG_fail;
25499 if (arg2 == NULL) {
25500 SWIG_null_ref("wxDateSpan");
25501 }
25502 if (SWIG_arg_fail(2)) SWIG_fail;
25503 }
25504 {
25505 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 {
25507 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25508 result = (wxDateSpan *) &_result_ref;
25509 }
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25524 wxDateSpan *result;
25525 PyObject * obj0 = 0 ;
25526 char *kwnames[] = {
25527 (char *) "self", NULL
25528 };
25529
25530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25532 if (SWIG_arg_fail(1)) SWIG_fail;
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 {
25536 wxDateSpan &_result_ref = (arg1)->Neg();
25537 result = (wxDateSpan *) &_result_ref;
25538 }
25539
25540 wxPyEndAllowThreads(__tstate);
25541 if (PyErr_Occurred()) SWIG_fail;
25542 }
25543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25551 PyObject *resultobj;
25552 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25553 int arg2 ;
25554 wxDateSpan *result;
25555 PyObject * obj0 = 0 ;
25556 PyObject * obj1 = 0 ;
25557 char *kwnames[] = {
25558 (char *) "self",(char *) "factor", NULL
25559 };
25560
25561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25563 if (SWIG_arg_fail(1)) SWIG_fail;
25564 {
25565 arg2 = (int)(SWIG_As_int(obj1));
25566 if (SWIG_arg_fail(2)) SWIG_fail;
25567 }
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 {
25571 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25572 result = (wxDateSpan *) &_result_ref;
25573 }
25574
25575 wxPyEndAllowThreads(__tstate);
25576 if (PyErr_Occurred()) SWIG_fail;
25577 }
25578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25586 PyObject *resultobj;
25587 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25588 wxDateSpan *arg2 = 0 ;
25589 wxDateSpan *result;
25590 PyObject * obj0 = 0 ;
25591 PyObject * obj1 = 0 ;
25592 char *kwnames[] = {
25593 (char *) "self",(char *) "other", NULL
25594 };
25595
25596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25598 if (SWIG_arg_fail(1)) SWIG_fail;
25599 {
25600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25601 if (SWIG_arg_fail(2)) SWIG_fail;
25602 if (arg2 == NULL) {
25603 SWIG_null_ref("wxDateSpan");
25604 }
25605 if (SWIG_arg_fail(2)) SWIG_fail;
25606 }
25607 {
25608 PyThreadState* __tstate = wxPyBeginAllowThreads();
25609 {
25610 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25611 result = (wxDateSpan *) &_result_ref;
25612 }
25613
25614 wxPyEndAllowThreads(__tstate);
25615 if (PyErr_Occurred()) SWIG_fail;
25616 }
25617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25618 return resultobj;
25619 fail:
25620 return NULL;
25621 }
25622
25623
25624 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj;
25626 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25627 wxDateSpan *arg2 = 0 ;
25628 wxDateSpan *result;
25629 PyObject * obj0 = 0 ;
25630 PyObject * obj1 = 0 ;
25631 char *kwnames[] = {
25632 (char *) "self",(char *) "other", NULL
25633 };
25634
25635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25637 if (SWIG_arg_fail(1)) SWIG_fail;
25638 {
25639 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25640 if (SWIG_arg_fail(2)) SWIG_fail;
25641 if (arg2 == NULL) {
25642 SWIG_null_ref("wxDateSpan");
25643 }
25644 if (SWIG_arg_fail(2)) SWIG_fail;
25645 }
25646 {
25647 PyThreadState* __tstate = wxPyBeginAllowThreads();
25648 {
25649 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25650 result = (wxDateSpan *) &_result_ref;
25651 }
25652
25653 wxPyEndAllowThreads(__tstate);
25654 if (PyErr_Occurred()) SWIG_fail;
25655 }
25656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj;
25665 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25666 wxDateSpan *result;
25667 PyObject * obj0 = 0 ;
25668 char *kwnames[] = {
25669 (char *) "self", NULL
25670 };
25671
25672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25674 if (SWIG_arg_fail(1)) SWIG_fail;
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 {
25678 wxDateSpan &_result_ref = (arg1)->operator -();
25679 result = (wxDateSpan *) &_result_ref;
25680 }
25681
25682 wxPyEndAllowThreads(__tstate);
25683 if (PyErr_Occurred()) SWIG_fail;
25684 }
25685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25686 return resultobj;
25687 fail:
25688 return NULL;
25689 }
25690
25691
25692 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25693 PyObject *resultobj;
25694 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25695 int arg2 ;
25696 wxDateSpan *result;
25697 PyObject * obj0 = 0 ;
25698 PyObject * obj1 = 0 ;
25699 char *kwnames[] = {
25700 (char *) "self",(char *) "factor", NULL
25701 };
25702
25703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25705 if (SWIG_arg_fail(1)) SWIG_fail;
25706 {
25707 arg2 = (int)(SWIG_As_int(obj1));
25708 if (SWIG_arg_fail(2)) SWIG_fail;
25709 }
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 {
25713 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25714 result = (wxDateSpan *) &_result_ref;
25715 }
25716
25717 wxPyEndAllowThreads(__tstate);
25718 if (PyErr_Occurred()) SWIG_fail;
25719 }
25720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj;
25729 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25730 wxDateSpan *arg2 = 0 ;
25731 wxDateSpan result;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char *kwnames[] = {
25735 (char *) "self",(char *) "other", NULL
25736 };
25737
25738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25740 if (SWIG_arg_fail(1)) SWIG_fail;
25741 {
25742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(2)) SWIG_fail;
25744 if (arg2 == NULL) {
25745 SWIG_null_ref("wxDateSpan");
25746 }
25747 if (SWIG_arg_fail(2)) SWIG_fail;
25748 }
25749 {
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25752
25753 wxPyEndAllowThreads(__tstate);
25754 if (PyErr_Occurred()) SWIG_fail;
25755 }
25756 {
25757 wxDateSpan * resultptr;
25758 resultptr = new wxDateSpan((wxDateSpan &)(result));
25759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25760 }
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25768 PyObject *resultobj;
25769 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25770 wxDateSpan *arg2 = 0 ;
25771 wxDateSpan result;
25772 PyObject * obj0 = 0 ;
25773 PyObject * obj1 = 0 ;
25774 char *kwnames[] = {
25775 (char *) "self",(char *) "other", NULL
25776 };
25777
25778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25780 if (SWIG_arg_fail(1)) SWIG_fail;
25781 {
25782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25783 if (SWIG_arg_fail(2)) SWIG_fail;
25784 if (arg2 == NULL) {
25785 SWIG_null_ref("wxDateSpan");
25786 }
25787 if (SWIG_arg_fail(2)) SWIG_fail;
25788 }
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25792
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 {
25797 wxDateSpan * resultptr;
25798 resultptr = new wxDateSpan((wxDateSpan &)(result));
25799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25800 }
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj;
25809 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25810 int arg2 ;
25811 wxDateSpan result;
25812 PyObject * obj0 = 0 ;
25813 PyObject * obj1 = 0 ;
25814 char *kwnames[] = {
25815 (char *) "self",(char *) "n", NULL
25816 };
25817
25818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25820 if (SWIG_arg_fail(1)) SWIG_fail;
25821 {
25822 arg2 = (int)(SWIG_As_int(obj1));
25823 if (SWIG_arg_fail(2)) SWIG_fail;
25824 }
25825 {
25826 PyThreadState* __tstate = wxPyBeginAllowThreads();
25827 result = wxDateSpan___mul__(arg1,arg2);
25828
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 {
25833 wxDateSpan * resultptr;
25834 resultptr = new wxDateSpan((wxDateSpan &)(result));
25835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25836 }
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj;
25845 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25846 int arg2 ;
25847 wxDateSpan result;
25848 PyObject * obj0 = 0 ;
25849 PyObject * obj1 = 0 ;
25850 char *kwnames[] = {
25851 (char *) "self",(char *) "n", NULL
25852 };
25853
25854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25856 if (SWIG_arg_fail(1)) SWIG_fail;
25857 {
25858 arg2 = (int)(SWIG_As_int(obj1));
25859 if (SWIG_arg_fail(2)) SWIG_fail;
25860 }
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 result = wxDateSpan___rmul__(arg1,arg2);
25864
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 {
25869 wxDateSpan * resultptr;
25870 resultptr = new wxDateSpan((wxDateSpan &)(result));
25871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25872 }
25873 return resultobj;
25874 fail:
25875 return NULL;
25876 }
25877
25878
25879 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25880 PyObject *resultobj;
25881 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25882 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25883 bool result;
25884 PyObject * obj0 = 0 ;
25885 PyObject * obj1 = 0 ;
25886 char *kwnames[] = {
25887 (char *) "self",(char *) "other", NULL
25888 };
25889
25890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25892 if (SWIG_arg_fail(1)) SWIG_fail;
25893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25894 if (SWIG_arg_fail(2)) SWIG_fail;
25895 {
25896 PyThreadState* __tstate = wxPyBeginAllowThreads();
25897 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25898
25899 wxPyEndAllowThreads(__tstate);
25900 if (PyErr_Occurred()) SWIG_fail;
25901 }
25902 {
25903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25904 }
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25912 PyObject *resultobj;
25913 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25914 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25915 bool result;
25916 PyObject * obj0 = 0 ;
25917 PyObject * obj1 = 0 ;
25918 char *kwnames[] = {
25919 (char *) "self",(char *) "other", NULL
25920 };
25921
25922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25924 if (SWIG_arg_fail(1)) SWIG_fail;
25925 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25926 if (SWIG_arg_fail(2)) SWIG_fail;
25927 {
25928 PyThreadState* __tstate = wxPyBeginAllowThreads();
25929 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25930
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 {
25935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25936 }
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25944 PyObject *obj;
25945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25946 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25947 Py_INCREF(obj);
25948 return Py_BuildValue((char *)"");
25949 }
25950 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj;
25952 long result;
25953 char *kwnames[] = {
25954 NULL
25955 };
25956
25957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = (long)wxGetLocalTime();
25961
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 {
25966 resultobj = SWIG_From_long((long)(result));
25967 }
25968 return resultobj;
25969 fail:
25970 return NULL;
25971 }
25972
25973
25974 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25975 PyObject *resultobj;
25976 long result;
25977 char *kwnames[] = {
25978 NULL
25979 };
25980
25981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 result = (long)wxGetUTCTime();
25985
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 {
25990 resultobj = SWIG_From_long((long)(result));
25991 }
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 long result;
26001 char *kwnames[] = {
26002 NULL
26003 };
26004
26005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26006 {
26007 PyThreadState* __tstate = wxPyBeginAllowThreads();
26008 result = (long)wxGetCurrentTime();
26009
26010 wxPyEndAllowThreads(__tstate);
26011 if (PyErr_Occurred()) SWIG_fail;
26012 }
26013 {
26014 resultobj = SWIG_From_long((long)(result));
26015 }
26016 return resultobj;
26017 fail:
26018 return NULL;
26019 }
26020
26021
26022 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26023 PyObject *resultobj;
26024 wxLongLong result;
26025 char *kwnames[] = {
26026 NULL
26027 };
26028
26029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = wxGetLocalTimeMillis();
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 {
26038 PyObject *hi, *lo, *shifter, *shifted;
26039 hi = PyLong_FromLong( (&result)->GetHi() );
26040 lo = PyLong_FromLong( (&result)->GetLo() );
26041 shifter = PyLong_FromLong(32);
26042 shifted = PyNumber_Lshift(hi, shifter);
26043 resultobj = PyNumber_Or(shifted, lo);
26044 Py_DECREF(hi);
26045 Py_DECREF(lo);
26046 Py_DECREF(shifter);
26047 Py_DECREF(shifted);
26048 }
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 static int _wrap_DefaultDateTime_set(PyObject *) {
26056 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26057 return 1;
26058 }
26059
26060
26061 static PyObject *_wrap_DefaultDateTime_get(void) {
26062 PyObject *pyobj;
26063
26064 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26065 return pyobj;
26066 }
26067
26068
26069 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj;
26071 wxDataFormatId arg1 ;
26072 wxDataFormat *result;
26073 PyObject * obj0 = 0 ;
26074 char *kwnames[] = {
26075 (char *) "type", NULL
26076 };
26077
26078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26079 {
26080 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26081 if (SWIG_arg_fail(1)) SWIG_fail;
26082 }
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj;
26099 wxString *arg1 = 0 ;
26100 wxDataFormat *result;
26101 bool temp1 = false ;
26102 PyObject * obj0 = 0 ;
26103 char *kwnames[] = {
26104 (char *) "format", NULL
26105 };
26106
26107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26108 {
26109 arg1 = wxString_in_helper(obj0);
26110 if (arg1 == NULL) SWIG_fail;
26111 temp1 = true;
26112 }
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26116
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26121 {
26122 if (temp1)
26123 delete arg1;
26124 }
26125 return resultobj;
26126 fail:
26127 {
26128 if (temp1)
26129 delete arg1;
26130 }
26131 return NULL;
26132 }
26133
26134
26135 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26136 PyObject *resultobj;
26137 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26138 PyObject * obj0 = 0 ;
26139 char *kwnames[] = {
26140 (char *) "self", NULL
26141 };
26142
26143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26145 if (SWIG_arg_fail(1)) SWIG_fail;
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 delete arg1;
26149
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 Py_INCREF(Py_None); resultobj = Py_None;
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26161 PyObject *resultobj;
26162 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26163 wxDataFormatId arg2 ;
26164 bool result;
26165 PyObject * obj0 = 0 ;
26166 PyObject * obj1 = 0 ;
26167
26168 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26170 if (SWIG_arg_fail(1)) SWIG_fail;
26171 {
26172 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26173 if (SWIG_arg_fail(2)) SWIG_fail;
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26178
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 {
26183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26184 }
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26192 PyObject *resultobj;
26193 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26194 wxDataFormatId arg2 ;
26195 bool result;
26196 PyObject * obj0 = 0 ;
26197 PyObject * obj1 = 0 ;
26198
26199 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26201 if (SWIG_arg_fail(1)) SWIG_fail;
26202 {
26203 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26204 if (SWIG_arg_fail(2)) SWIG_fail;
26205 }
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26209
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 {
26214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26215 }
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26223 PyObject *resultobj;
26224 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26225 wxDataFormat *arg2 = 0 ;
26226 bool result;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229
26230 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26232 if (SWIG_arg_fail(1)) SWIG_fail;
26233 {
26234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26235 if (SWIG_arg_fail(2)) SWIG_fail;
26236 if (arg2 == NULL) {
26237 SWIG_null_ref("wxDataFormat");
26238 }
26239 if (SWIG_arg_fail(2)) SWIG_fail;
26240 }
26241 {
26242 PyThreadState* __tstate = wxPyBeginAllowThreads();
26243 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26244
26245 wxPyEndAllowThreads(__tstate);
26246 if (PyErr_Occurred()) SWIG_fail;
26247 }
26248 {
26249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26250 }
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26258 int argc;
26259 PyObject *argv[3];
26260 int ii;
26261
26262 argc = PyObject_Length(args);
26263 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26264 argv[ii] = PyTuple_GetItem(args,ii);
26265 }
26266 if (argc == 2) {
26267 int _v;
26268 {
26269 void *ptr;
26270 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26271 _v = 0;
26272 PyErr_Clear();
26273 } else {
26274 _v = 1;
26275 }
26276 }
26277 if (_v) {
26278 {
26279 void *ptr = 0;
26280 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26281 _v = 0;
26282 PyErr_Clear();
26283 } else {
26284 _v = (ptr != 0);
26285 }
26286 }
26287 if (_v) {
26288 return _wrap_DataFormat___eq____SWIG_1(self,args);
26289 }
26290 }
26291 }
26292 if (argc == 2) {
26293 int _v;
26294 {
26295 void *ptr;
26296 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26297 _v = 0;
26298 PyErr_Clear();
26299 } else {
26300 _v = 1;
26301 }
26302 }
26303 if (_v) {
26304 _v = SWIG_Check_int(argv[1]);
26305 if (_v) {
26306 return _wrap_DataFormat___eq____SWIG_0(self,args);
26307 }
26308 }
26309 }
26310
26311 Py_INCREF(Py_NotImplemented);
26312 return Py_NotImplemented;
26313 }
26314
26315
26316 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26317 PyObject *resultobj;
26318 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26319 wxDataFormat *arg2 = 0 ;
26320 bool result;
26321 PyObject * obj0 = 0 ;
26322 PyObject * obj1 = 0 ;
26323
26324 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26326 if (SWIG_arg_fail(1)) SWIG_fail;
26327 {
26328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26329 if (SWIG_arg_fail(2)) SWIG_fail;
26330 if (arg2 == NULL) {
26331 SWIG_null_ref("wxDataFormat");
26332 }
26333 if (SWIG_arg_fail(2)) SWIG_fail;
26334 }
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26338
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 {
26343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26344 }
26345 return resultobj;
26346 fail:
26347 return NULL;
26348 }
26349
26350
26351 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26352 int argc;
26353 PyObject *argv[3];
26354 int ii;
26355
26356 argc = PyObject_Length(args);
26357 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26358 argv[ii] = PyTuple_GetItem(args,ii);
26359 }
26360 if (argc == 2) {
26361 int _v;
26362 {
26363 void *ptr;
26364 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26365 _v = 0;
26366 PyErr_Clear();
26367 } else {
26368 _v = 1;
26369 }
26370 }
26371 if (_v) {
26372 {
26373 void *ptr = 0;
26374 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26375 _v = 0;
26376 PyErr_Clear();
26377 } else {
26378 _v = (ptr != 0);
26379 }
26380 }
26381 if (_v) {
26382 return _wrap_DataFormat___ne____SWIG_1(self,args);
26383 }
26384 }
26385 }
26386 if (argc == 2) {
26387 int _v;
26388 {
26389 void *ptr;
26390 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26391 _v = 0;
26392 PyErr_Clear();
26393 } else {
26394 _v = 1;
26395 }
26396 }
26397 if (_v) {
26398 _v = SWIG_Check_int(argv[1]);
26399 if (_v) {
26400 return _wrap_DataFormat___ne____SWIG_0(self,args);
26401 }
26402 }
26403 }
26404
26405 Py_INCREF(Py_NotImplemented);
26406 return Py_NotImplemented;
26407 }
26408
26409
26410 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26411 PyObject *resultobj;
26412 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26413 wxDataFormatId arg2 ;
26414 PyObject * obj0 = 0 ;
26415 PyObject * obj1 = 0 ;
26416 char *kwnames[] = {
26417 (char *) "self",(char *) "format", NULL
26418 };
26419
26420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) 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 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26425 if (SWIG_arg_fail(2)) SWIG_fail;
26426 }
26427 {
26428 PyThreadState* __tstate = wxPyBeginAllowThreads();
26429 (arg1)->SetType((wxDataFormatId )arg2);
26430
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 Py_INCREF(Py_None); resultobj = Py_None;
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26442 PyObject *resultobj;
26443 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26444 wxDataFormatId result;
26445 PyObject * obj0 = 0 ;
26446 char *kwnames[] = {
26447 (char *) "self", NULL
26448 };
26449
26450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26452 if (SWIG_arg_fail(1)) SWIG_fail;
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26456
26457 wxPyEndAllowThreads(__tstate);
26458 if (PyErr_Occurred()) SWIG_fail;
26459 }
26460 resultobj = SWIG_From_int((result));
26461 return resultobj;
26462 fail:
26463 return NULL;
26464 }
26465
26466
26467 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26468 PyObject *resultobj;
26469 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26470 wxString result;
26471 PyObject * obj0 = 0 ;
26472 char *kwnames[] = {
26473 (char *) "self", NULL
26474 };
26475
26476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26478 if (SWIG_arg_fail(1)) SWIG_fail;
26479 {
26480 PyThreadState* __tstate = wxPyBeginAllowThreads();
26481 result = ((wxDataFormat const *)arg1)->GetId();
26482
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 {
26487 #if wxUSE_UNICODE
26488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26489 #else
26490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26491 #endif
26492 }
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26500 PyObject *resultobj;
26501 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26502 wxString *arg2 = 0 ;
26503 bool temp2 = false ;
26504 PyObject * obj0 = 0 ;
26505 PyObject * obj1 = 0 ;
26506 char *kwnames[] = {
26507 (char *) "self",(char *) "format", NULL
26508 };
26509
26510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26512 if (SWIG_arg_fail(1)) SWIG_fail;
26513 {
26514 arg2 = wxString_in_helper(obj1);
26515 if (arg2 == NULL) SWIG_fail;
26516 temp2 = true;
26517 }
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 (arg1)->SetId((wxString const &)*arg2);
26521
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 Py_INCREF(Py_None); resultobj = Py_None;
26526 {
26527 if (temp2)
26528 delete arg2;
26529 }
26530 return resultobj;
26531 fail:
26532 {
26533 if (temp2)
26534 delete arg2;
26535 }
26536 return NULL;
26537 }
26538
26539
26540 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26541 PyObject *obj;
26542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26543 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26544 Py_INCREF(obj);
26545 return Py_BuildValue((char *)"");
26546 }
26547 static int _wrap_FormatInvalid_set(PyObject *) {
26548 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26549 return 1;
26550 }
26551
26552
26553 static PyObject *_wrap_FormatInvalid_get(void) {
26554 PyObject *pyobj;
26555
26556 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26557 return pyobj;
26558 }
26559
26560
26561 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj;
26563 wxDataObject *arg1 = (wxDataObject *) 0 ;
26564 PyObject * obj0 = 0 ;
26565 char *kwnames[] = {
26566 (char *) "self", NULL
26567 };
26568
26569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26571 if (SWIG_arg_fail(1)) SWIG_fail;
26572 {
26573 PyThreadState* __tstate = wxPyBeginAllowThreads();
26574 delete arg1;
26575
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 Py_INCREF(Py_None); resultobj = Py_None;
26580 return resultobj;
26581 fail:
26582 return NULL;
26583 }
26584
26585
26586 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26587 PyObject *resultobj;
26588 wxDataObject *arg1 = (wxDataObject *) 0 ;
26589 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26590 SwigValueWrapper<wxDataFormat > result;
26591 PyObject * obj0 = 0 ;
26592 PyObject * obj1 = 0 ;
26593 char *kwnames[] = {
26594 (char *) "self",(char *) "dir", NULL
26595 };
26596
26597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26599 if (SWIG_arg_fail(1)) SWIG_fail;
26600 if (obj1) {
26601 {
26602 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26603 if (SWIG_arg_fail(2)) SWIG_fail;
26604 }
26605 }
26606 {
26607 PyThreadState* __tstate = wxPyBeginAllowThreads();
26608 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26609
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 {
26614 wxDataFormat * resultptr;
26615 resultptr = new wxDataFormat((wxDataFormat &)(result));
26616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26617 }
26618 return resultobj;
26619 fail:
26620 return NULL;
26621 }
26622
26623
26624 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26625 PyObject *resultobj;
26626 wxDataObject *arg1 = (wxDataObject *) 0 ;
26627 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26628 size_t result;
26629 PyObject * obj0 = 0 ;
26630 PyObject * obj1 = 0 ;
26631 char *kwnames[] = {
26632 (char *) "self",(char *) "dir", NULL
26633 };
26634
26635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26637 if (SWIG_arg_fail(1)) SWIG_fail;
26638 if (obj1) {
26639 {
26640 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26641 if (SWIG_arg_fail(2)) SWIG_fail;
26642 }
26643 }
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26647
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 {
26652 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26653 }
26654 return resultobj;
26655 fail:
26656 return NULL;
26657 }
26658
26659
26660 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj;
26662 wxDataObject *arg1 = (wxDataObject *) 0 ;
26663 wxDataFormat *arg2 = 0 ;
26664 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26665 bool result;
26666 PyObject * obj0 = 0 ;
26667 PyObject * obj1 = 0 ;
26668 PyObject * obj2 = 0 ;
26669 char *kwnames[] = {
26670 (char *) "self",(char *) "format",(char *) "dir", NULL
26671 };
26672
26673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26675 if (SWIG_arg_fail(1)) SWIG_fail;
26676 {
26677 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26678 if (SWIG_arg_fail(2)) SWIG_fail;
26679 if (arg2 == NULL) {
26680 SWIG_null_ref("wxDataFormat");
26681 }
26682 if (SWIG_arg_fail(2)) SWIG_fail;
26683 }
26684 if (obj2) {
26685 {
26686 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26687 if (SWIG_arg_fail(3)) SWIG_fail;
26688 }
26689 }
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26693
26694 wxPyEndAllowThreads(__tstate);
26695 if (PyErr_Occurred()) SWIG_fail;
26696 }
26697 {
26698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26699 }
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26707 PyObject *resultobj;
26708 wxDataObject *arg1 = (wxDataObject *) 0 ;
26709 wxDataFormat *arg2 = 0 ;
26710 size_t result;
26711 PyObject * obj0 = 0 ;
26712 PyObject * obj1 = 0 ;
26713 char *kwnames[] = {
26714 (char *) "self",(char *) "format", NULL
26715 };
26716
26717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26719 if (SWIG_arg_fail(1)) SWIG_fail;
26720 {
26721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26722 if (SWIG_arg_fail(2)) SWIG_fail;
26723 if (arg2 == NULL) {
26724 SWIG_null_ref("wxDataFormat");
26725 }
26726 if (SWIG_arg_fail(2)) SWIG_fail;
26727 }
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26731
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 {
26736 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26737 }
26738 return resultobj;
26739 fail:
26740 return NULL;
26741 }
26742
26743
26744 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26745 PyObject *resultobj;
26746 wxDataObject *arg1 = (wxDataObject *) 0 ;
26747 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26748 PyObject *result;
26749 PyObject * obj0 = 0 ;
26750 PyObject * obj1 = 0 ;
26751 char *kwnames[] = {
26752 (char *) "self",(char *) "dir", NULL
26753 };
26754
26755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26757 if (SWIG_arg_fail(1)) SWIG_fail;
26758 if (obj1) {
26759 {
26760 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26761 if (SWIG_arg_fail(2)) SWIG_fail;
26762 }
26763 }
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26767
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 resultobj = result;
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26779 PyObject *resultobj;
26780 wxDataObject *arg1 = (wxDataObject *) 0 ;
26781 wxDataFormat *arg2 = 0 ;
26782 PyObject *result;
26783 PyObject * obj0 = 0 ;
26784 PyObject * obj1 = 0 ;
26785 char *kwnames[] = {
26786 (char *) "self",(char *) "format", NULL
26787 };
26788
26789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26791 if (SWIG_arg_fail(1)) SWIG_fail;
26792 {
26793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26794 if (SWIG_arg_fail(2)) SWIG_fail;
26795 if (arg2 == NULL) {
26796 SWIG_null_ref("wxDataFormat");
26797 }
26798 if (SWIG_arg_fail(2)) SWIG_fail;
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26803
26804 wxPyEndAllowThreads(__tstate);
26805 if (PyErr_Occurred()) SWIG_fail;
26806 }
26807 resultobj = result;
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26815 PyObject *resultobj;
26816 wxDataObject *arg1 = (wxDataObject *) 0 ;
26817 wxDataFormat *arg2 = 0 ;
26818 PyObject *arg3 = (PyObject *) 0 ;
26819 bool result;
26820 PyObject * obj0 = 0 ;
26821 PyObject * obj1 = 0 ;
26822 PyObject * obj2 = 0 ;
26823 char *kwnames[] = {
26824 (char *) "self",(char *) "format",(char *) "data", NULL
26825 };
26826
26827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26829 if (SWIG_arg_fail(1)) SWIG_fail;
26830 {
26831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26832 if (SWIG_arg_fail(2)) SWIG_fail;
26833 if (arg2 == NULL) {
26834 SWIG_null_ref("wxDataFormat");
26835 }
26836 if (SWIG_arg_fail(2)) SWIG_fail;
26837 }
26838 arg3 = obj2;
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26842
26843 wxPyEndAllowThreads(__tstate);
26844 if (PyErr_Occurred()) SWIG_fail;
26845 }
26846 {
26847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26848 }
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26856 PyObject *obj;
26857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26858 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26859 Py_INCREF(obj);
26860 return Py_BuildValue((char *)"");
26861 }
26862 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26863 PyObject *resultobj;
26864 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26865 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26866 wxDataObjectSimple *result;
26867 PyObject * obj0 = 0 ;
26868 char *kwnames[] = {
26869 (char *) "format", NULL
26870 };
26871
26872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26873 if (obj0) {
26874 {
26875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26876 if (SWIG_arg_fail(1)) SWIG_fail;
26877 if (arg1 == NULL) {
26878 SWIG_null_ref("wxDataFormat");
26879 }
26880 if (SWIG_arg_fail(1)) SWIG_fail;
26881 }
26882 }
26883 {
26884 PyThreadState* __tstate = wxPyBeginAllowThreads();
26885 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26886
26887 wxPyEndAllowThreads(__tstate);
26888 if (PyErr_Occurred()) SWIG_fail;
26889 }
26890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26891 return resultobj;
26892 fail:
26893 return NULL;
26894 }
26895
26896
26897 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26898 PyObject *resultobj;
26899 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26900 wxDataFormat *result;
26901 PyObject * obj0 = 0 ;
26902 char *kwnames[] = {
26903 (char *) "self", NULL
26904 };
26905
26906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26911 {
26912 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26913 result = (wxDataFormat *) &_result_ref;
26914 }
26915
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26927 PyObject *resultobj;
26928 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26929 wxDataFormat *arg2 = 0 ;
26930 PyObject * obj0 = 0 ;
26931 PyObject * obj1 = 0 ;
26932 char *kwnames[] = {
26933 (char *) "self",(char *) "format", NULL
26934 };
26935
26936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26938 if (SWIG_arg_fail(1)) SWIG_fail;
26939 {
26940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26941 if (SWIG_arg_fail(2)) SWIG_fail;
26942 if (arg2 == NULL) {
26943 SWIG_null_ref("wxDataFormat");
26944 }
26945 if (SWIG_arg_fail(2)) SWIG_fail;
26946 }
26947 {
26948 PyThreadState* __tstate = wxPyBeginAllowThreads();
26949 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26950
26951 wxPyEndAllowThreads(__tstate);
26952 if (PyErr_Occurred()) SWIG_fail;
26953 }
26954 Py_INCREF(Py_None); resultobj = Py_None;
26955 return resultobj;
26956 fail:
26957 return NULL;
26958 }
26959
26960
26961 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26962 PyObject *resultobj;
26963 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26964 size_t result;
26965 PyObject * obj0 = 0 ;
26966 char *kwnames[] = {
26967 (char *) "self", NULL
26968 };
26969
26970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26972 if (SWIG_arg_fail(1)) SWIG_fail;
26973 {
26974 PyThreadState* __tstate = wxPyBeginAllowThreads();
26975 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26976
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 {
26981 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26990 PyObject *resultobj;
26991 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26992 PyObject *result;
26993 PyObject * obj0 = 0 ;
26994 char *kwnames[] = {
26995 (char *) "self", NULL
26996 };
26997
26998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
26999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27000 if (SWIG_arg_fail(1)) SWIG_fail;
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 resultobj = result;
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27016 PyObject *resultobj;
27017 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27018 PyObject *arg2 = (PyObject *) 0 ;
27019 bool result;
27020 PyObject * obj0 = 0 ;
27021 PyObject * obj1 = 0 ;
27022 char *kwnames[] = {
27023 (char *) "self",(char *) "data", NULL
27024 };
27025
27026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27028 if (SWIG_arg_fail(1)) SWIG_fail;
27029 arg2 = obj1;
27030 {
27031 PyThreadState* __tstate = wxPyBeginAllowThreads();
27032 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27033
27034 wxPyEndAllowThreads(__tstate);
27035 if (PyErr_Occurred()) SWIG_fail;
27036 }
27037 {
27038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27039 }
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27047 PyObject *obj;
27048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27049 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27050 Py_INCREF(obj);
27051 return Py_BuildValue((char *)"");
27052 }
27053 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj;
27055 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27056 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27057 wxPyDataObjectSimple *result;
27058 PyObject * obj0 = 0 ;
27059 char *kwnames[] = {
27060 (char *) "format", NULL
27061 };
27062
27063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27064 if (obj0) {
27065 {
27066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27067 if (SWIG_arg_fail(1)) SWIG_fail;
27068 if (arg1 == NULL) {
27069 SWIG_null_ref("wxDataFormat");
27070 }
27071 if (SWIG_arg_fail(1)) SWIG_fail;
27072 }
27073 }
27074 {
27075 PyThreadState* __tstate = wxPyBeginAllowThreads();
27076 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27077
27078 wxPyEndAllowThreads(__tstate);
27079 if (PyErr_Occurred()) SWIG_fail;
27080 }
27081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj;
27090 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27091 PyObject *arg2 = (PyObject *) 0 ;
27092 PyObject *arg3 = (PyObject *) 0 ;
27093 PyObject * obj0 = 0 ;
27094 PyObject * obj1 = 0 ;
27095 PyObject * obj2 = 0 ;
27096 char *kwnames[] = {
27097 (char *) "self",(char *) "self",(char *) "_class", NULL
27098 };
27099
27100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27102 if (SWIG_arg_fail(1)) SWIG_fail;
27103 arg2 = obj1;
27104 arg3 = obj2;
27105 {
27106 PyThreadState* __tstate = wxPyBeginAllowThreads();
27107 (arg1)->_setCallbackInfo(arg2,arg3);
27108
27109 wxPyEndAllowThreads(__tstate);
27110 if (PyErr_Occurred()) SWIG_fail;
27111 }
27112 Py_INCREF(Py_None); resultobj = Py_None;
27113 return resultobj;
27114 fail:
27115 return NULL;
27116 }
27117
27118
27119 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27120 PyObject *obj;
27121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27122 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27123 Py_INCREF(obj);
27124 return Py_BuildValue((char *)"");
27125 }
27126 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27127 PyObject *resultobj;
27128 wxDataObjectComposite *result;
27129 char *kwnames[] = {
27130 NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27134 {
27135 PyThreadState* __tstate = wxPyBeginAllowThreads();
27136 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27137
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27149 PyObject *resultobj;
27150 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27151 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27152 bool arg3 = (bool) false ;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 PyObject * obj2 = 0 ;
27156 char *kwnames[] = {
27157 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27158 };
27159
27160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27162 if (SWIG_arg_fail(1)) SWIG_fail;
27163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27164 if (SWIG_arg_fail(2)) SWIG_fail;
27165 if (obj2) {
27166 {
27167 arg3 = (bool)(SWIG_As_bool(obj2));
27168 if (SWIG_arg_fail(3)) SWIG_fail;
27169 }
27170 }
27171 {
27172 PyThreadState* __tstate = wxPyBeginAllowThreads();
27173 (arg1)->Add(arg2,arg3);
27174
27175 wxPyEndAllowThreads(__tstate);
27176 if (PyErr_Occurred()) SWIG_fail;
27177 }
27178 Py_INCREF(Py_None); resultobj = Py_None;
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27186 PyObject *obj;
27187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27188 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27189 Py_INCREF(obj);
27190 return Py_BuildValue((char *)"");
27191 }
27192 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27193 PyObject *resultobj;
27194 wxString const &arg1_defvalue = wxPyEmptyString ;
27195 wxString *arg1 = (wxString *) &arg1_defvalue ;
27196 wxTextDataObject *result;
27197 bool temp1 = false ;
27198 PyObject * obj0 = 0 ;
27199 char *kwnames[] = {
27200 (char *) "text", NULL
27201 };
27202
27203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27204 if (obj0) {
27205 {
27206 arg1 = wxString_in_helper(obj0);
27207 if (arg1 == NULL) SWIG_fail;
27208 temp1 = true;
27209 }
27210 }
27211 {
27212 PyThreadState* __tstate = wxPyBeginAllowThreads();
27213 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27214
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27219 {
27220 if (temp1)
27221 delete arg1;
27222 }
27223 return resultobj;
27224 fail:
27225 {
27226 if (temp1)
27227 delete arg1;
27228 }
27229 return NULL;
27230 }
27231
27232
27233 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27234 PyObject *resultobj;
27235 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27236 size_t result;
27237 PyObject * obj0 = 0 ;
27238 char *kwnames[] = {
27239 (char *) "self", NULL
27240 };
27241
27242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27244 if (SWIG_arg_fail(1)) SWIG_fail;
27245 {
27246 PyThreadState* __tstate = wxPyBeginAllowThreads();
27247 result = (size_t)(arg1)->GetTextLength();
27248
27249 wxPyEndAllowThreads(__tstate);
27250 if (PyErr_Occurred()) SWIG_fail;
27251 }
27252 {
27253 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27254 }
27255 return resultobj;
27256 fail:
27257 return NULL;
27258 }
27259
27260
27261 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27262 PyObject *resultobj;
27263 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27264 wxString result;
27265 PyObject * obj0 = 0 ;
27266 char *kwnames[] = {
27267 (char *) "self", NULL
27268 };
27269
27270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27272 if (SWIG_arg_fail(1)) SWIG_fail;
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 result = (arg1)->GetText();
27276
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 {
27281 #if wxUSE_UNICODE
27282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27283 #else
27284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27285 #endif
27286 }
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj;
27295 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27296 wxString *arg2 = 0 ;
27297 bool temp2 = false ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "self",(char *) "text", NULL
27302 };
27303
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(1)) SWIG_fail;
27307 {
27308 arg2 = wxString_in_helper(obj1);
27309 if (arg2 == NULL) SWIG_fail;
27310 temp2 = true;
27311 }
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 (arg1)->SetText((wxString const &)*arg2);
27315
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 Py_INCREF(Py_None); resultobj = Py_None;
27320 {
27321 if (temp2)
27322 delete arg2;
27323 }
27324 return resultobj;
27325 fail:
27326 {
27327 if (temp2)
27328 delete arg2;
27329 }
27330 return NULL;
27331 }
27332
27333
27334 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27335 PyObject *obj;
27336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27337 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27338 Py_INCREF(obj);
27339 return Py_BuildValue((char *)"");
27340 }
27341 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj;
27343 wxString const &arg1_defvalue = wxPyEmptyString ;
27344 wxString *arg1 = (wxString *) &arg1_defvalue ;
27345 wxPyTextDataObject *result;
27346 bool temp1 = false ;
27347 PyObject * obj0 = 0 ;
27348 char *kwnames[] = {
27349 (char *) "text", NULL
27350 };
27351
27352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27353 if (obj0) {
27354 {
27355 arg1 = wxString_in_helper(obj0);
27356 if (arg1 == NULL) SWIG_fail;
27357 temp1 = true;
27358 }
27359 }
27360 {
27361 PyThreadState* __tstate = wxPyBeginAllowThreads();
27362 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27363
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27368 {
27369 if (temp1)
27370 delete arg1;
27371 }
27372 return resultobj;
27373 fail:
27374 {
27375 if (temp1)
27376 delete arg1;
27377 }
27378 return NULL;
27379 }
27380
27381
27382 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj;
27384 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27385 PyObject *arg2 = (PyObject *) 0 ;
27386 PyObject *arg3 = (PyObject *) 0 ;
27387 PyObject * obj0 = 0 ;
27388 PyObject * obj1 = 0 ;
27389 PyObject * obj2 = 0 ;
27390 char *kwnames[] = {
27391 (char *) "self",(char *) "self",(char *) "_class", NULL
27392 };
27393
27394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27396 if (SWIG_arg_fail(1)) SWIG_fail;
27397 arg2 = obj1;
27398 arg3 = obj2;
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 (arg1)->_setCallbackInfo(arg2,arg3);
27402
27403 wxPyEndAllowThreads(__tstate);
27404 if (PyErr_Occurred()) SWIG_fail;
27405 }
27406 Py_INCREF(Py_None); resultobj = Py_None;
27407 return resultobj;
27408 fail:
27409 return NULL;
27410 }
27411
27412
27413 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27414 PyObject *obj;
27415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27416 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27417 Py_INCREF(obj);
27418 return Py_BuildValue((char *)"");
27419 }
27420 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27421 PyObject *resultobj;
27422 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27423 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27424 wxBitmapDataObject *result;
27425 PyObject * obj0 = 0 ;
27426 char *kwnames[] = {
27427 (char *) "bitmap", NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27431 if (obj0) {
27432 {
27433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27434 if (SWIG_arg_fail(1)) SWIG_fail;
27435 if (arg1 == NULL) {
27436 SWIG_null_ref("wxBitmap");
27437 }
27438 if (SWIG_arg_fail(1)) SWIG_fail;
27439 }
27440 }
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27444
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27456 PyObject *resultobj;
27457 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27458 wxBitmap result;
27459 PyObject * obj0 = 0 ;
27460 char *kwnames[] = {
27461 (char *) "self", NULL
27462 };
27463
27464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27466 if (SWIG_arg_fail(1)) SWIG_fail;
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27470
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 {
27475 wxBitmap * resultptr;
27476 resultptr = new wxBitmap((wxBitmap &)(result));
27477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27478 }
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj;
27487 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27488 wxBitmap *arg2 = 0 ;
27489 PyObject * obj0 = 0 ;
27490 PyObject * obj1 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "self",(char *) "bitmap", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(1)) SWIG_fail;
27498 {
27499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27500 if (SWIG_arg_fail(2)) SWIG_fail;
27501 if (arg2 == NULL) {
27502 SWIG_null_ref("wxBitmap");
27503 }
27504 if (SWIG_arg_fail(2)) SWIG_fail;
27505 }
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 Py_INCREF(Py_None); resultobj = Py_None;
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27521 PyObject *obj;
27522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27523 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27524 Py_INCREF(obj);
27525 return Py_BuildValue((char *)"");
27526 }
27527 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj;
27529 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27530 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27531 wxPyBitmapDataObject *result;
27532 PyObject * obj0 = 0 ;
27533 char *kwnames[] = {
27534 (char *) "bitmap", NULL
27535 };
27536
27537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27538 if (obj0) {
27539 {
27540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27541 if (SWIG_arg_fail(1)) SWIG_fail;
27542 if (arg1 == NULL) {
27543 SWIG_null_ref("wxBitmap");
27544 }
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 }
27547 }
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27556 return resultobj;
27557 fail:
27558 return NULL;
27559 }
27560
27561
27562 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27563 PyObject *resultobj;
27564 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27565 PyObject *arg2 = (PyObject *) 0 ;
27566 PyObject *arg3 = (PyObject *) 0 ;
27567 PyObject * obj0 = 0 ;
27568 PyObject * obj1 = 0 ;
27569 PyObject * obj2 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self",(char *) "self",(char *) "_class", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 arg2 = obj1;
27578 arg3 = obj2;
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->_setCallbackInfo(arg2,arg3);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 Py_INCREF(Py_None); resultobj = Py_None;
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27594 PyObject *obj;
27595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27596 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27597 Py_INCREF(obj);
27598 return Py_BuildValue((char *)"");
27599 }
27600 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxFileDataObject *result;
27603 char *kwnames[] = {
27604 NULL
27605 };
27606
27607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 result = (wxFileDataObject *)new wxFileDataObject();
27611
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj;
27624 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27625 wxArrayString *result;
27626 PyObject * obj0 = 0 ;
27627 char *kwnames[] = {
27628 (char *) "self", NULL
27629 };
27630
27631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27633 if (SWIG_arg_fail(1)) SWIG_fail;
27634 {
27635 PyThreadState* __tstate = wxPyBeginAllowThreads();
27636 {
27637 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27638 result = (wxArrayString *) &_result_ref;
27639 }
27640
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 {
27645 resultobj = wxArrayString2PyList_helper(*result);
27646 }
27647 return resultobj;
27648 fail:
27649 return NULL;
27650 }
27651
27652
27653 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27654 PyObject *resultobj;
27655 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27656 wxString *arg2 = 0 ;
27657 bool temp2 = false ;
27658 PyObject * obj0 = 0 ;
27659 PyObject * obj1 = 0 ;
27660 char *kwnames[] = {
27661 (char *) "self",(char *) "filename", NULL
27662 };
27663
27664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27666 if (SWIG_arg_fail(1)) SWIG_fail;
27667 {
27668 arg2 = wxString_in_helper(obj1);
27669 if (arg2 == NULL) SWIG_fail;
27670 temp2 = true;
27671 }
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 (arg1)->AddFile((wxString const &)*arg2);
27675
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 Py_INCREF(Py_None); resultobj = Py_None;
27680 {
27681 if (temp2)
27682 delete arg2;
27683 }
27684 return resultobj;
27685 fail:
27686 {
27687 if (temp2)
27688 delete arg2;
27689 }
27690 return NULL;
27691 }
27692
27693
27694 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27695 PyObject *obj;
27696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27697 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27698 Py_INCREF(obj);
27699 return Py_BuildValue((char *)"");
27700 }
27701 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27702 PyObject *resultobj;
27703 wxDataFormat *arg1 = 0 ;
27704 wxCustomDataObject *result;
27705 PyObject * obj0 = 0 ;
27706
27707 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27708 {
27709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(1)) SWIG_fail;
27711 if (arg1 == NULL) {
27712 SWIG_null_ref("wxDataFormat");
27713 }
27714 if (SWIG_arg_fail(1)) SWIG_fail;
27715 }
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27719
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27731 PyObject *resultobj;
27732 wxString *arg1 = 0 ;
27733 wxCustomDataObject *result;
27734 bool temp1 = false ;
27735 PyObject * obj0 = 0 ;
27736
27737 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27738 {
27739 arg1 = wxString_in_helper(obj0);
27740 if (arg1 == NULL) SWIG_fail;
27741 temp1 = true;
27742 }
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27746
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27751 {
27752 if (temp1)
27753 delete arg1;
27754 }
27755 return resultobj;
27756 fail:
27757 {
27758 if (temp1)
27759 delete arg1;
27760 }
27761 return NULL;
27762 }
27763
27764
27765 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27766 PyObject *resultobj;
27767 wxCustomDataObject *result;
27768
27769 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27770 {
27771 PyThreadState* __tstate = wxPyBeginAllowThreads();
27772 result = (wxCustomDataObject *)new wxCustomDataObject();
27773
27774 wxPyEndAllowThreads(__tstate);
27775 if (PyErr_Occurred()) SWIG_fail;
27776 }
27777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27778 return resultobj;
27779 fail:
27780 return NULL;
27781 }
27782
27783
27784 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27785 int argc;
27786 PyObject *argv[2];
27787 int ii;
27788
27789 argc = PyObject_Length(args);
27790 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27791 argv[ii] = PyTuple_GetItem(args,ii);
27792 }
27793 if (argc == 0) {
27794 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27795 }
27796 if (argc == 1) {
27797 int _v;
27798 {
27799 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27800 }
27801 if (_v) {
27802 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27803 }
27804 }
27805 if (argc == 1) {
27806 int _v;
27807 {
27808 void *ptr = 0;
27809 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27810 _v = 0;
27811 PyErr_Clear();
27812 } else {
27813 _v = (ptr != 0);
27814 }
27815 }
27816 if (_v) {
27817 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27818 }
27819 }
27820
27821 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27822 return NULL;
27823 }
27824
27825
27826 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj;
27828 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27829 PyObject *arg2 = (PyObject *) 0 ;
27830 bool result;
27831 PyObject * obj0 = 0 ;
27832 PyObject * obj1 = 0 ;
27833 char *kwnames[] = {
27834 (char *) "self",(char *) "data", NULL
27835 };
27836
27837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27839 if (SWIG_arg_fail(1)) SWIG_fail;
27840 arg2 = obj1;
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27844
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 {
27849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27850 }
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27858 PyObject *resultobj;
27859 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27860 size_t result;
27861 PyObject * obj0 = 0 ;
27862 char *kwnames[] = {
27863 (char *) "self", NULL
27864 };
27865
27866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27868 if (SWIG_arg_fail(1)) SWIG_fail;
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 result = (size_t)(arg1)->GetSize();
27872
27873 wxPyEndAllowThreads(__tstate);
27874 if (PyErr_Occurred()) SWIG_fail;
27875 }
27876 {
27877 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27886 PyObject *resultobj;
27887 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27888 PyObject *result;
27889 PyObject * obj0 = 0 ;
27890 char *kwnames[] = {
27891 (char *) "self", NULL
27892 };
27893
27894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27896 if (SWIG_arg_fail(1)) SWIG_fail;
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27900
27901 wxPyEndAllowThreads(__tstate);
27902 if (PyErr_Occurred()) SWIG_fail;
27903 }
27904 resultobj = result;
27905 return resultobj;
27906 fail:
27907 return NULL;
27908 }
27909
27910
27911 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27912 PyObject *obj;
27913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27914 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27915 Py_INCREF(obj);
27916 return Py_BuildValue((char *)"");
27917 }
27918 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27919 PyObject *resultobj;
27920 wxURLDataObject *result;
27921 char *kwnames[] = {
27922 NULL
27923 };
27924
27925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = (wxURLDataObject *)new wxURLDataObject();
27929
27930 wxPyEndAllowThreads(__tstate);
27931 if (PyErr_Occurred()) SWIG_fail;
27932 }
27933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27934 return resultobj;
27935 fail:
27936 return NULL;
27937 }
27938
27939
27940 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27941 PyObject *resultobj;
27942 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27943 wxString result;
27944 PyObject * obj0 = 0 ;
27945 char *kwnames[] = {
27946 (char *) "self", NULL
27947 };
27948
27949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27951 if (SWIG_arg_fail(1)) SWIG_fail;
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 result = (arg1)->GetURL();
27955
27956 wxPyEndAllowThreads(__tstate);
27957 if (PyErr_Occurred()) SWIG_fail;
27958 }
27959 {
27960 #if wxUSE_UNICODE
27961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27962 #else
27963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27964 #endif
27965 }
27966 return resultobj;
27967 fail:
27968 return NULL;
27969 }
27970
27971
27972 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27973 PyObject *resultobj;
27974 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27975 wxString *arg2 = 0 ;
27976 bool temp2 = false ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char *kwnames[] = {
27980 (char *) "self",(char *) "url", NULL
27981 };
27982
27983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27985 if (SWIG_arg_fail(1)) SWIG_fail;
27986 {
27987 arg2 = wxString_in_helper(obj1);
27988 if (arg2 == NULL) SWIG_fail;
27989 temp2 = true;
27990 }
27991 {
27992 PyThreadState* __tstate = wxPyBeginAllowThreads();
27993 (arg1)->SetURL((wxString const &)*arg2);
27994
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 Py_INCREF(Py_None); resultobj = Py_None;
27999 {
28000 if (temp2)
28001 delete arg2;
28002 }
28003 return resultobj;
28004 fail:
28005 {
28006 if (temp2)
28007 delete arg2;
28008 }
28009 return NULL;
28010 }
28011
28012
28013 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28014 PyObject *obj;
28015 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28016 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28017 Py_INCREF(obj);
28018 return Py_BuildValue((char *)"");
28019 }
28020 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj;
28022 wxMetafileDataObject *result;
28023 char *kwnames[] = {
28024 NULL
28025 };
28026
28027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28028 {
28029 PyThreadState* __tstate = wxPyBeginAllowThreads();
28030 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28031
28032 wxPyEndAllowThreads(__tstate);
28033 if (PyErr_Occurred()) SWIG_fail;
28034 }
28035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28036 return resultobj;
28037 fail:
28038 return NULL;
28039 }
28040
28041
28042 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28043 PyObject *obj;
28044 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28045 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28046 Py_INCREF(obj);
28047 return Py_BuildValue((char *)"");
28048 }
28049 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj;
28051 wxDragResult arg1 ;
28052 bool result;
28053 PyObject * obj0 = 0 ;
28054 char *kwnames[] = {
28055 (char *) "res", NULL
28056 };
28057
28058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28059 {
28060 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 }
28063 {
28064 PyThreadState* __tstate = wxPyBeginAllowThreads();
28065 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28066
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 {
28071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28072 }
28073 return resultobj;
28074 fail:
28075 return NULL;
28076 }
28077
28078
28079 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28080 PyObject *resultobj;
28081 wxWindow *arg1 = (wxWindow *) 0 ;
28082 wxIcon const &arg2_defvalue = wxNullIcon ;
28083 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28084 wxIcon const &arg3_defvalue = wxNullIcon ;
28085 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28086 wxIcon const &arg4_defvalue = wxNullIcon ;
28087 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28088 wxPyDropSource *result;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 PyObject * obj2 = 0 ;
28092 PyObject * obj3 = 0 ;
28093 char *kwnames[] = {
28094 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28095 };
28096
28097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28099 if (SWIG_arg_fail(1)) SWIG_fail;
28100 if (obj1) {
28101 {
28102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28103 if (SWIG_arg_fail(2)) SWIG_fail;
28104 if (arg2 == NULL) {
28105 SWIG_null_ref("wxIcon");
28106 }
28107 if (SWIG_arg_fail(2)) SWIG_fail;
28108 }
28109 }
28110 if (obj2) {
28111 {
28112 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28113 if (SWIG_arg_fail(3)) SWIG_fail;
28114 if (arg3 == NULL) {
28115 SWIG_null_ref("wxIcon");
28116 }
28117 if (SWIG_arg_fail(3)) SWIG_fail;
28118 }
28119 }
28120 if (obj3) {
28121 {
28122 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(4)) SWIG_fail;
28124 if (arg4 == NULL) {
28125 SWIG_null_ref("wxIcon");
28126 }
28127 if (SWIG_arg_fail(4)) SWIG_fail;
28128 }
28129 }
28130 {
28131 PyThreadState* __tstate = wxPyBeginAllowThreads();
28132 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28133
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj;
28146 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28147 PyObject *arg2 = (PyObject *) 0 ;
28148 PyObject *arg3 = (PyObject *) 0 ;
28149 int arg4 ;
28150 PyObject * obj0 = 0 ;
28151 PyObject * obj1 = 0 ;
28152 PyObject * obj2 = 0 ;
28153 PyObject * obj3 = 0 ;
28154 char *kwnames[] = {
28155 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28156 };
28157
28158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28160 if (SWIG_arg_fail(1)) SWIG_fail;
28161 arg2 = obj1;
28162 arg3 = obj2;
28163 {
28164 arg4 = (int)(SWIG_As_int(obj3));
28165 if (SWIG_arg_fail(4)) SWIG_fail;
28166 }
28167 {
28168 PyThreadState* __tstate = wxPyBeginAllowThreads();
28169 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28170
28171 wxPyEndAllowThreads(__tstate);
28172 if (PyErr_Occurred()) SWIG_fail;
28173 }
28174 Py_INCREF(Py_None); resultobj = Py_None;
28175 return resultobj;
28176 fail:
28177 return NULL;
28178 }
28179
28180
28181 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28182 PyObject *resultobj;
28183 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28184 PyObject * obj0 = 0 ;
28185 char *kwnames[] = {
28186 (char *) "self", NULL
28187 };
28188
28189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 delete arg1;
28195
28196 wxPyEndAllowThreads(__tstate);
28197 if (PyErr_Occurred()) SWIG_fail;
28198 }
28199 Py_INCREF(Py_None); resultobj = Py_None;
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj;
28208 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28209 wxDataObject *arg2 = 0 ;
28210 PyObject * obj0 = 0 ;
28211 PyObject * obj1 = 0 ;
28212 char *kwnames[] = {
28213 (char *) "self",(char *) "data", NULL
28214 };
28215
28216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28218 if (SWIG_arg_fail(1)) SWIG_fail;
28219 {
28220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28221 if (SWIG_arg_fail(2)) SWIG_fail;
28222 if (arg2 == NULL) {
28223 SWIG_null_ref("wxDataObject");
28224 }
28225 if (SWIG_arg_fail(2)) SWIG_fail;
28226 }
28227 {
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 (arg1)->SetData(*arg2);
28230
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 Py_INCREF(Py_None); resultobj = Py_None;
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj;
28243 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28244 wxDataObject *result;
28245 PyObject * obj0 = 0 ;
28246 char *kwnames[] = {
28247 (char *) "self", NULL
28248 };
28249
28250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28252 if (SWIG_arg_fail(1)) SWIG_fail;
28253 {
28254 PyThreadState* __tstate = wxPyBeginAllowThreads();
28255 result = (wxDataObject *)(arg1)->GetDataObject();
28256
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28261 return resultobj;
28262 fail:
28263 return NULL;
28264 }
28265
28266
28267 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28268 PyObject *resultobj;
28269 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28270 wxDragResult arg2 ;
28271 wxCursor *arg3 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 PyObject * obj1 = 0 ;
28274 PyObject * obj2 = 0 ;
28275 char *kwnames[] = {
28276 (char *) "self",(char *) "res",(char *) "cursor", NULL
28277 };
28278
28279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(1)) SWIG_fail;
28282 {
28283 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28284 if (SWIG_arg_fail(2)) SWIG_fail;
28285 }
28286 {
28287 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28288 if (SWIG_arg_fail(3)) SWIG_fail;
28289 if (arg3 == NULL) {
28290 SWIG_null_ref("wxCursor");
28291 }
28292 if (SWIG_arg_fail(3)) SWIG_fail;
28293 }
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28297
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 Py_INCREF(Py_None); resultobj = Py_None;
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28309 PyObject *resultobj;
28310 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28311 int arg2 = (int) wxDrag_CopyOnly ;
28312 wxDragResult result;
28313 PyObject * obj0 = 0 ;
28314 PyObject * obj1 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self",(char *) "flags", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 if (obj1) {
28323 {
28324 arg2 = (int)(SWIG_As_int(obj1));
28325 if (SWIG_arg_fail(2)) SWIG_fail;
28326 }
28327 }
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 resultobj = SWIG_From_int((result));
28336 return resultobj;
28337 fail:
28338 return NULL;
28339 }
28340
28341
28342 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28343 PyObject *resultobj;
28344 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28345 wxDragResult arg2 ;
28346 bool result;
28347 PyObject * obj0 = 0 ;
28348 PyObject * obj1 = 0 ;
28349 char *kwnames[] = {
28350 (char *) "self",(char *) "effect", NULL
28351 };
28352
28353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28355 if (SWIG_arg_fail(1)) SWIG_fail;
28356 {
28357 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28358 if (SWIG_arg_fail(2)) SWIG_fail;
28359 }
28360 {
28361 PyThreadState* __tstate = wxPyBeginAllowThreads();
28362 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28363
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 {
28368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28369 }
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28377 PyObject *obj;
28378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28379 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28380 Py_INCREF(obj);
28381 return Py_BuildValue((char *)"");
28382 }
28383 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj;
28385 wxDataObject *arg1 = (wxDataObject *) NULL ;
28386 wxPyDropTarget *result;
28387 PyObject * obj0 = 0 ;
28388 char *kwnames[] = {
28389 (char *) "dataObject", NULL
28390 };
28391
28392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28393 if (obj0) {
28394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28395 if (SWIG_arg_fail(1)) SWIG_fail;
28396 }
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28400
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28412 PyObject *resultobj;
28413 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28414 PyObject *arg2 = (PyObject *) 0 ;
28415 PyObject *arg3 = (PyObject *) 0 ;
28416 PyObject * obj0 = 0 ;
28417 PyObject * obj1 = 0 ;
28418 PyObject * obj2 = 0 ;
28419 char *kwnames[] = {
28420 (char *) "self",(char *) "self",(char *) "_class", NULL
28421 };
28422
28423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28425 if (SWIG_arg_fail(1)) SWIG_fail;
28426 arg2 = obj1;
28427 arg3 = obj2;
28428 {
28429 PyThreadState* __tstate = wxPyBeginAllowThreads();
28430 (arg1)->_setCallbackInfo(arg2,arg3);
28431
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 Py_INCREF(Py_None); resultobj = Py_None;
28436 return resultobj;
28437 fail:
28438 return NULL;
28439 }
28440
28441
28442 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28443 PyObject *resultobj;
28444 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28445 PyObject * obj0 = 0 ;
28446 char *kwnames[] = {
28447 (char *) "self", NULL
28448 };
28449
28450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28452 if (SWIG_arg_fail(1)) SWIG_fail;
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 delete arg1;
28456
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 Py_INCREF(Py_None); resultobj = Py_None;
28461 return resultobj;
28462 fail:
28463 return NULL;
28464 }
28465
28466
28467 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28468 PyObject *resultobj;
28469 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28470 wxDataObject *result;
28471 PyObject * obj0 = 0 ;
28472 char *kwnames[] = {
28473 (char *) "self", NULL
28474 };
28475
28476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28478 if (SWIG_arg_fail(1)) SWIG_fail;
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = (wxDataObject *)(arg1)->GetDataObject();
28482
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28494 PyObject *resultobj;
28495 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28496 wxDataObject *arg2 = (wxDataObject *) 0 ;
28497 PyObject * obj0 = 0 ;
28498 PyObject * obj1 = 0 ;
28499 char *kwnames[] = {
28500 (char *) "self",(char *) "dataObject", NULL
28501 };
28502
28503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28505 if (SWIG_arg_fail(1)) SWIG_fail;
28506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28507 if (SWIG_arg_fail(2)) SWIG_fail;
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 (arg1)->SetDataObject(arg2);
28511
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 Py_INCREF(Py_None); resultobj = Py_None;
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28523 PyObject *resultobj;
28524 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28525 int arg2 ;
28526 int arg3 ;
28527 wxDragResult arg4 ;
28528 wxDragResult result;
28529 PyObject * obj0 = 0 ;
28530 PyObject * obj1 = 0 ;
28531 PyObject * obj2 = 0 ;
28532 PyObject * obj3 = 0 ;
28533 char *kwnames[] = {
28534 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28535 };
28536
28537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28539 if (SWIG_arg_fail(1)) SWIG_fail;
28540 {
28541 arg2 = (int)(SWIG_As_int(obj1));
28542 if (SWIG_arg_fail(2)) SWIG_fail;
28543 }
28544 {
28545 arg3 = (int)(SWIG_As_int(obj2));
28546 if (SWIG_arg_fail(3)) SWIG_fail;
28547 }
28548 {
28549 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28550 if (SWIG_arg_fail(4)) SWIG_fail;
28551 }
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 resultobj = SWIG_From_int((result));
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj;
28568 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28569 int arg2 ;
28570 int arg3 ;
28571 wxDragResult arg4 ;
28572 wxDragResult result;
28573 PyObject * obj0 = 0 ;
28574 PyObject * obj1 = 0 ;
28575 PyObject * obj2 = 0 ;
28576 PyObject * obj3 = 0 ;
28577 char *kwnames[] = {
28578 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28579 };
28580
28581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28583 if (SWIG_arg_fail(1)) SWIG_fail;
28584 {
28585 arg2 = (int)(SWIG_As_int(obj1));
28586 if (SWIG_arg_fail(2)) SWIG_fail;
28587 }
28588 {
28589 arg3 = (int)(SWIG_As_int(obj2));
28590 if (SWIG_arg_fail(3)) SWIG_fail;
28591 }
28592 {
28593 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28594 if (SWIG_arg_fail(4)) SWIG_fail;
28595 }
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28599
28600 wxPyEndAllowThreads(__tstate);
28601 if (PyErr_Occurred()) SWIG_fail;
28602 }
28603 resultobj = SWIG_From_int((result));
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj;
28612 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28613 PyObject * obj0 = 0 ;
28614 char *kwnames[] = {
28615 (char *) "self", NULL
28616 };
28617
28618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 (arg1)->base_OnLeave();
28624
28625 wxPyEndAllowThreads(__tstate);
28626 if (PyErr_Occurred()) SWIG_fail;
28627 }
28628 Py_INCREF(Py_None); resultobj = Py_None;
28629 return resultobj;
28630 fail:
28631 return NULL;
28632 }
28633
28634
28635 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28636 PyObject *resultobj;
28637 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28638 int arg2 ;
28639 int arg3 ;
28640 bool result;
28641 PyObject * obj0 = 0 ;
28642 PyObject * obj1 = 0 ;
28643 PyObject * obj2 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "self",(char *) "x",(char *) "y", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 {
28652 arg2 = (int)(SWIG_As_int(obj1));
28653 if (SWIG_arg_fail(2)) SWIG_fail;
28654 }
28655 {
28656 arg3 = (int)(SWIG_As_int(obj2));
28657 if (SWIG_arg_fail(3)) SWIG_fail;
28658 }
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28662
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 {
28667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28668 }
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28676 PyObject *resultobj;
28677 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28678 bool result;
28679 PyObject * obj0 = 0 ;
28680 char *kwnames[] = {
28681 (char *) "self", NULL
28682 };
28683
28684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28686 if (SWIG_arg_fail(1)) SWIG_fail;
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = (bool)(arg1)->GetData();
28690
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28696 }
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28704 PyObject *obj;
28705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28706 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28707 Py_INCREF(obj);
28708 return Py_BuildValue((char *)"");
28709 }
28710 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj;
28712 wxPyTextDropTarget *result;
28713 char *kwnames[] = {
28714 NULL
28715 };
28716
28717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28718 {
28719 PyThreadState* __tstate = wxPyBeginAllowThreads();
28720 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28721
28722 wxPyEndAllowThreads(__tstate);
28723 if (PyErr_Occurred()) SWIG_fail;
28724 }
28725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28733 PyObject *resultobj;
28734 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28735 PyObject *arg2 = (PyObject *) 0 ;
28736 PyObject *arg3 = (PyObject *) 0 ;
28737 PyObject * obj0 = 0 ;
28738 PyObject * obj1 = 0 ;
28739 PyObject * obj2 = 0 ;
28740 char *kwnames[] = {
28741 (char *) "self",(char *) "self",(char *) "_class", NULL
28742 };
28743
28744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28746 if (SWIG_arg_fail(1)) SWIG_fail;
28747 arg2 = obj1;
28748 arg3 = obj2;
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 (arg1)->_setCallbackInfo(arg2,arg3);
28752
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 Py_INCREF(Py_None); resultobj = Py_None;
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj;
28765 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28766 int arg2 ;
28767 int arg3 ;
28768 wxDragResult arg4 ;
28769 wxDragResult result;
28770 PyObject * obj0 = 0 ;
28771 PyObject * obj1 = 0 ;
28772 PyObject * obj2 = 0 ;
28773 PyObject * obj3 = 0 ;
28774 char *kwnames[] = {
28775 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28776 };
28777
28778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28780 if (SWIG_arg_fail(1)) SWIG_fail;
28781 {
28782 arg2 = (int)(SWIG_As_int(obj1));
28783 if (SWIG_arg_fail(2)) SWIG_fail;
28784 }
28785 {
28786 arg3 = (int)(SWIG_As_int(obj2));
28787 if (SWIG_arg_fail(3)) SWIG_fail;
28788 }
28789 {
28790 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28791 if (SWIG_arg_fail(4)) SWIG_fail;
28792 }
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28796
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 resultobj = SWIG_From_int((result));
28801 return resultobj;
28802 fail:
28803 return NULL;
28804 }
28805
28806
28807 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28808 PyObject *resultobj;
28809 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28810 int arg2 ;
28811 int arg3 ;
28812 wxDragResult arg4 ;
28813 wxDragResult result;
28814 PyObject * obj0 = 0 ;
28815 PyObject * obj1 = 0 ;
28816 PyObject * obj2 = 0 ;
28817 PyObject * obj3 = 0 ;
28818 char *kwnames[] = {
28819 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28820 };
28821
28822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28824 if (SWIG_arg_fail(1)) SWIG_fail;
28825 {
28826 arg2 = (int)(SWIG_As_int(obj1));
28827 if (SWIG_arg_fail(2)) SWIG_fail;
28828 }
28829 {
28830 arg3 = (int)(SWIG_As_int(obj2));
28831 if (SWIG_arg_fail(3)) SWIG_fail;
28832 }
28833 {
28834 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28835 if (SWIG_arg_fail(4)) SWIG_fail;
28836 }
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28840
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 resultobj = SWIG_From_int((result));
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj;
28853 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28854 PyObject * obj0 = 0 ;
28855 char *kwnames[] = {
28856 (char *) "self", NULL
28857 };
28858
28859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 (arg1)->base_OnLeave();
28865
28866 wxPyEndAllowThreads(__tstate);
28867 if (PyErr_Occurred()) SWIG_fail;
28868 }
28869 Py_INCREF(Py_None); resultobj = Py_None;
28870 return resultobj;
28871 fail:
28872 return NULL;
28873 }
28874
28875
28876 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28877 PyObject *resultobj;
28878 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28879 int arg2 ;
28880 int arg3 ;
28881 bool result;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 PyObject * obj2 = 0 ;
28885 char *kwnames[] = {
28886 (char *) "self",(char *) "x",(char *) "y", NULL
28887 };
28888
28889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28891 if (SWIG_arg_fail(1)) SWIG_fail;
28892 {
28893 arg2 = (int)(SWIG_As_int(obj1));
28894 if (SWIG_arg_fail(2)) SWIG_fail;
28895 }
28896 {
28897 arg3 = (int)(SWIG_As_int(obj2));
28898 if (SWIG_arg_fail(3)) SWIG_fail;
28899 }
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28903
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 {
28908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28909 }
28910 return resultobj;
28911 fail:
28912 return NULL;
28913 }
28914
28915
28916 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28917 PyObject *resultobj;
28918 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28919 int arg2 ;
28920 int arg3 ;
28921 wxDragResult arg4 ;
28922 wxDragResult result;
28923 PyObject * obj0 = 0 ;
28924 PyObject * obj1 = 0 ;
28925 PyObject * obj2 = 0 ;
28926 PyObject * obj3 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28933 if (SWIG_arg_fail(1)) SWIG_fail;
28934 {
28935 arg2 = (int)(SWIG_As_int(obj1));
28936 if (SWIG_arg_fail(2)) SWIG_fail;
28937 }
28938 {
28939 arg3 = (int)(SWIG_As_int(obj2));
28940 if (SWIG_arg_fail(3)) SWIG_fail;
28941 }
28942 {
28943 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28944 if (SWIG_arg_fail(4)) SWIG_fail;
28945 }
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
28949
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 resultobj = SWIG_From_int((result));
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
28961 PyObject *obj;
28962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28963 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
28964 Py_INCREF(obj);
28965 return Py_BuildValue((char *)"");
28966 }
28967 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj;
28969 wxPyFileDropTarget *result;
28970 char *kwnames[] = {
28971 NULL
28972 };
28973
28974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
28975 {
28976 PyThreadState* __tstate = wxPyBeginAllowThreads();
28977 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
28978
28979 wxPyEndAllowThreads(__tstate);
28980 if (PyErr_Occurred()) SWIG_fail;
28981 }
28982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
28983 return resultobj;
28984 fail:
28985 return NULL;
28986 }
28987
28988
28989 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28990 PyObject *resultobj;
28991 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
28992 PyObject *arg2 = (PyObject *) 0 ;
28993 PyObject *arg3 = (PyObject *) 0 ;
28994 PyObject * obj0 = 0 ;
28995 PyObject * obj1 = 0 ;
28996 PyObject * obj2 = 0 ;
28997 char *kwnames[] = {
28998 (char *) "self",(char *) "self",(char *) "_class", NULL
28999 };
29000
29001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29003 if (SWIG_arg_fail(1)) SWIG_fail;
29004 arg2 = obj1;
29005 arg3 = obj2;
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 (arg1)->_setCallbackInfo(arg2,arg3);
29009
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 Py_INCREF(Py_None); resultobj = Py_None;
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29021 PyObject *resultobj;
29022 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29023 int arg2 ;
29024 int arg3 ;
29025 wxDragResult arg4 ;
29026 wxDragResult result;
29027 PyObject * obj0 = 0 ;
29028 PyObject * obj1 = 0 ;
29029 PyObject * obj2 = 0 ;
29030 PyObject * obj3 = 0 ;
29031 char *kwnames[] = {
29032 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29033 };
29034
29035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(1)) SWIG_fail;
29038 {
29039 arg2 = (int)(SWIG_As_int(obj1));
29040 if (SWIG_arg_fail(2)) SWIG_fail;
29041 }
29042 {
29043 arg3 = (int)(SWIG_As_int(obj2));
29044 if (SWIG_arg_fail(3)) SWIG_fail;
29045 }
29046 {
29047 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29048 if (SWIG_arg_fail(4)) SWIG_fail;
29049 }
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29053
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_From_int((result));
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj;
29066 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29067 int arg2 ;
29068 int arg3 ;
29069 wxDragResult arg4 ;
29070 wxDragResult result;
29071 PyObject * obj0 = 0 ;
29072 PyObject * obj1 = 0 ;
29073 PyObject * obj2 = 0 ;
29074 PyObject * obj3 = 0 ;
29075 char *kwnames[] = {
29076 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29077 };
29078
29079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29081 if (SWIG_arg_fail(1)) SWIG_fail;
29082 {
29083 arg2 = (int)(SWIG_As_int(obj1));
29084 if (SWIG_arg_fail(2)) SWIG_fail;
29085 }
29086 {
29087 arg3 = (int)(SWIG_As_int(obj2));
29088 if (SWIG_arg_fail(3)) SWIG_fail;
29089 }
29090 {
29091 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29092 if (SWIG_arg_fail(4)) SWIG_fail;
29093 }
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_From_int((result));
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29111 PyObject * obj0 = 0 ;
29112 char *kwnames[] = {
29113 (char *) "self", NULL
29114 };
29115
29116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 (arg1)->base_OnLeave();
29122
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 Py_INCREF(Py_None); resultobj = Py_None;
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj;
29135 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29136 int arg2 ;
29137 int arg3 ;
29138 bool result;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 PyObject * obj2 = 0 ;
29142 char *kwnames[] = {
29143 (char *) "self",(char *) "x",(char *) "y", NULL
29144 };
29145
29146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29148 if (SWIG_arg_fail(1)) SWIG_fail;
29149 {
29150 arg2 = (int)(SWIG_As_int(obj1));
29151 if (SWIG_arg_fail(2)) SWIG_fail;
29152 }
29153 {
29154 arg3 = (int)(SWIG_As_int(obj2));
29155 if (SWIG_arg_fail(3)) SWIG_fail;
29156 }
29157 {
29158 PyThreadState* __tstate = wxPyBeginAllowThreads();
29159 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29160
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 {
29165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29166 }
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj;
29175 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29176 int arg2 ;
29177 int arg3 ;
29178 wxDragResult arg4 ;
29179 wxDragResult result;
29180 PyObject * obj0 = 0 ;
29181 PyObject * obj1 = 0 ;
29182 PyObject * obj2 = 0 ;
29183 PyObject * obj3 = 0 ;
29184 char *kwnames[] = {
29185 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29186 };
29187
29188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29190 if (SWIG_arg_fail(1)) SWIG_fail;
29191 {
29192 arg2 = (int)(SWIG_As_int(obj1));
29193 if (SWIG_arg_fail(2)) SWIG_fail;
29194 }
29195 {
29196 arg3 = (int)(SWIG_As_int(obj2));
29197 if (SWIG_arg_fail(3)) SWIG_fail;
29198 }
29199 {
29200 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29201 if (SWIG_arg_fail(4)) SWIG_fail;
29202 }
29203 {
29204 PyThreadState* __tstate = wxPyBeginAllowThreads();
29205 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29206
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 resultobj = SWIG_From_int((result));
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29218 PyObject *obj;
29219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29220 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29221 Py_INCREF(obj);
29222 return Py_BuildValue((char *)"");
29223 }
29224 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj;
29226 wxClipboard *result;
29227 char *kwnames[] = {
29228 NULL
29229 };
29230
29231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 result = (wxClipboard *)new wxClipboard();
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxClipboard *arg1 = (wxClipboard *) 0 ;
29249 PyObject * obj0 = 0 ;
29250 char *kwnames[] = {
29251 (char *) "self", NULL
29252 };
29253
29254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29256 if (SWIG_arg_fail(1)) SWIG_fail;
29257 {
29258 PyThreadState* __tstate = wxPyBeginAllowThreads();
29259 delete arg1;
29260
29261 wxPyEndAllowThreads(__tstate);
29262 if (PyErr_Occurred()) SWIG_fail;
29263 }
29264 Py_INCREF(Py_None); resultobj = Py_None;
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29272 PyObject *resultobj;
29273 wxClipboard *arg1 = (wxClipboard *) 0 ;
29274 bool result;
29275 PyObject * obj0 = 0 ;
29276 char *kwnames[] = {
29277 (char *) "self", NULL
29278 };
29279
29280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29282 if (SWIG_arg_fail(1)) SWIG_fail;
29283 {
29284 PyThreadState* __tstate = wxPyBeginAllowThreads();
29285 result = (bool)(arg1)->Open();
29286
29287 wxPyEndAllowThreads(__tstate);
29288 if (PyErr_Occurred()) SWIG_fail;
29289 }
29290 {
29291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29292 }
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj;
29301 wxClipboard *arg1 = (wxClipboard *) 0 ;
29302 PyObject * obj0 = 0 ;
29303 char *kwnames[] = {
29304 (char *) "self", NULL
29305 };
29306
29307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29309 if (SWIG_arg_fail(1)) SWIG_fail;
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 (arg1)->Close();
29313
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 Py_INCREF(Py_None); resultobj = Py_None;
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29325 PyObject *resultobj;
29326 wxClipboard *arg1 = (wxClipboard *) 0 ;
29327 bool result;
29328 PyObject * obj0 = 0 ;
29329 char *kwnames[] = {
29330 (char *) "self", NULL
29331 };
29332
29333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) 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 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29339
29340 wxPyEndAllowThreads(__tstate);
29341 if (PyErr_Occurred()) SWIG_fail;
29342 }
29343 {
29344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29345 }
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj;
29354 wxClipboard *arg1 = (wxClipboard *) 0 ;
29355 wxDataObject *arg2 = (wxDataObject *) 0 ;
29356 bool result;
29357 PyObject * obj0 = 0 ;
29358 PyObject * obj1 = 0 ;
29359 char *kwnames[] = {
29360 (char *) "self",(char *) "data", NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(1)) SWIG_fail;
29366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29367 if (SWIG_arg_fail(2)) SWIG_fail;
29368 {
29369 PyThreadState* __tstate = wxPyBeginAllowThreads();
29370 result = (bool)(arg1)->AddData(arg2);
29371
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 {
29376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29377 }
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29385 PyObject *resultobj;
29386 wxClipboard *arg1 = (wxClipboard *) 0 ;
29387 wxDataObject *arg2 = (wxDataObject *) 0 ;
29388 bool result;
29389 PyObject * obj0 = 0 ;
29390 PyObject * obj1 = 0 ;
29391 char *kwnames[] = {
29392 (char *) "self",(char *) "data", NULL
29393 };
29394
29395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29397 if (SWIG_arg_fail(1)) SWIG_fail;
29398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29399 if (SWIG_arg_fail(2)) SWIG_fail;
29400 {
29401 PyThreadState* __tstate = wxPyBeginAllowThreads();
29402 result = (bool)(arg1)->SetData(arg2);
29403
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 {
29408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29409 }
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29417 PyObject *resultobj;
29418 wxClipboard *arg1 = (wxClipboard *) 0 ;
29419 wxDataFormat *arg2 = 0 ;
29420 bool result;
29421 PyObject * obj0 = 0 ;
29422 PyObject * obj1 = 0 ;
29423 char *kwnames[] = {
29424 (char *) "self",(char *) "format", NULL
29425 };
29426
29427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29429 if (SWIG_arg_fail(1)) SWIG_fail;
29430 {
29431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29432 if (SWIG_arg_fail(2)) SWIG_fail;
29433 if (arg2 == NULL) {
29434 SWIG_null_ref("wxDataFormat");
29435 }
29436 if (SWIG_arg_fail(2)) SWIG_fail;
29437 }
29438 {
29439 PyThreadState* __tstate = wxPyBeginAllowThreads();
29440 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29441
29442 wxPyEndAllowThreads(__tstate);
29443 if (PyErr_Occurred()) SWIG_fail;
29444 }
29445 {
29446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29447 }
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29455 PyObject *resultobj;
29456 wxClipboard *arg1 = (wxClipboard *) 0 ;
29457 wxDataObject *arg2 = 0 ;
29458 bool result;
29459 PyObject * obj0 = 0 ;
29460 PyObject * obj1 = 0 ;
29461 char *kwnames[] = {
29462 (char *) "self",(char *) "data", NULL
29463 };
29464
29465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29467 if (SWIG_arg_fail(1)) SWIG_fail;
29468 {
29469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29470 if (SWIG_arg_fail(2)) SWIG_fail;
29471 if (arg2 == NULL) {
29472 SWIG_null_ref("wxDataObject");
29473 }
29474 if (SWIG_arg_fail(2)) SWIG_fail;
29475 }
29476 {
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = (bool)(arg1)->GetData(*arg2);
29479
29480 wxPyEndAllowThreads(__tstate);
29481 if (PyErr_Occurred()) SWIG_fail;
29482 }
29483 {
29484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29485 }
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj;
29494 wxClipboard *arg1 = (wxClipboard *) 0 ;
29495 PyObject * obj0 = 0 ;
29496 char *kwnames[] = {
29497 (char *) "self", NULL
29498 };
29499
29500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29502 if (SWIG_arg_fail(1)) SWIG_fail;
29503 {
29504 PyThreadState* __tstate = wxPyBeginAllowThreads();
29505 (arg1)->Clear();
29506
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 Py_INCREF(Py_None); resultobj = Py_None;
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29518 PyObject *resultobj;
29519 wxClipboard *arg1 = (wxClipboard *) 0 ;
29520 bool result;
29521 PyObject * obj0 = 0 ;
29522 char *kwnames[] = {
29523 (char *) "self", NULL
29524 };
29525
29526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29528 if (SWIG_arg_fail(1)) SWIG_fail;
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = (bool)(arg1)->Flush();
29532
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 {
29537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29538 }
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj;
29547 wxClipboard *arg1 = (wxClipboard *) 0 ;
29548 bool arg2 = (bool) true ;
29549 PyObject * obj0 = 0 ;
29550 PyObject * obj1 = 0 ;
29551 char *kwnames[] = {
29552 (char *) "self",(char *) "primary", NULL
29553 };
29554
29555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29557 if (SWIG_arg_fail(1)) SWIG_fail;
29558 if (obj1) {
29559 {
29560 arg2 = (bool)(SWIG_As_bool(obj1));
29561 if (SWIG_arg_fail(2)) SWIG_fail;
29562 }
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 (arg1)->UsePrimarySelection(arg2);
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 Py_INCREF(Py_None); resultobj = Py_None;
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj;
29580 wxClipboard *result;
29581 char *kwnames[] = {
29582 NULL
29583 };
29584
29585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (wxClipboard *)wxClipboard::Get();
29589
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29601 PyObject *obj;
29602 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29603 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29604 Py_INCREF(obj);
29605 return Py_BuildValue((char *)"");
29606 }
29607 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj;
29609 wxClipboard *arg1 = (wxClipboard *) NULL ;
29610 wxClipboardLocker *result;
29611 PyObject * obj0 = 0 ;
29612 char *kwnames[] = {
29613 (char *) "clipboard", NULL
29614 };
29615
29616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29617 if (obj0) {
29618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29619 if (SWIG_arg_fail(1)) SWIG_fail;
29620 }
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29624
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29636 PyObject *resultobj;
29637 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29638 PyObject * obj0 = 0 ;
29639 char *kwnames[] = {
29640 (char *) "self", NULL
29641 };
29642
29643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29645 if (SWIG_arg_fail(1)) SWIG_fail;
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 delete arg1;
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 Py_INCREF(Py_None); resultobj = Py_None;
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj;
29662 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29663 bool result;
29664 PyObject * obj0 = 0 ;
29665 char *kwnames[] = {
29666 (char *) "self", NULL
29667 };
29668
29669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29671 if (SWIG_arg_fail(1)) SWIG_fail;
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = (bool)wxClipboardLocker___nonzero__(arg1);
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 {
29680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29681 }
29682 return resultobj;
29683 fail:
29684 return NULL;
29685 }
29686
29687
29688 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29689 PyObject *obj;
29690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29691 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29692 Py_INCREF(obj);
29693 return Py_BuildValue((char *)"");
29694 }
29695 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj;
29697 int arg1 = (int) 0 ;
29698 int arg2 = (int) 0 ;
29699 int arg3 = (int) 0 ;
29700 int arg4 = (int) 0 ;
29701 wxVideoMode *result;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 PyObject * obj2 = 0 ;
29705 PyObject * obj3 = 0 ;
29706 char *kwnames[] = {
29707 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29708 };
29709
29710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29711 if (obj0) {
29712 {
29713 arg1 = (int)(SWIG_As_int(obj0));
29714 if (SWIG_arg_fail(1)) SWIG_fail;
29715 }
29716 }
29717 if (obj1) {
29718 {
29719 arg2 = (int)(SWIG_As_int(obj1));
29720 if (SWIG_arg_fail(2)) SWIG_fail;
29721 }
29722 }
29723 if (obj2) {
29724 {
29725 arg3 = (int)(SWIG_As_int(obj2));
29726 if (SWIG_arg_fail(3)) SWIG_fail;
29727 }
29728 }
29729 if (obj3) {
29730 {
29731 arg4 = (int)(SWIG_As_int(obj3));
29732 if (SWIG_arg_fail(4)) SWIG_fail;
29733 }
29734 }
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29738
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29743 return resultobj;
29744 fail:
29745 return NULL;
29746 }
29747
29748
29749 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj;
29751 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29752 PyObject * obj0 = 0 ;
29753 char *kwnames[] = {
29754 (char *) "self", NULL
29755 };
29756
29757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29759 if (SWIG_arg_fail(1)) SWIG_fail;
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 delete arg1;
29763
29764 wxPyEndAllowThreads(__tstate);
29765 if (PyErr_Occurred()) SWIG_fail;
29766 }
29767 Py_INCREF(Py_None); resultobj = Py_None;
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj;
29776 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29777 wxVideoMode *arg2 = 0 ;
29778 bool result;
29779 PyObject * obj0 = 0 ;
29780 PyObject * obj1 = 0 ;
29781 char *kwnames[] = {
29782 (char *) "self",(char *) "other", NULL
29783 };
29784
29785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29787 if (SWIG_arg_fail(1)) SWIG_fail;
29788 {
29789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29790 if (SWIG_arg_fail(2)) SWIG_fail;
29791 if (arg2 == NULL) {
29792 SWIG_null_ref("wxVideoMode");
29793 }
29794 if (SWIG_arg_fail(2)) SWIG_fail;
29795 }
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29799
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 {
29804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29805 }
29806 return resultobj;
29807 fail:
29808 return NULL;
29809 }
29810
29811
29812 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29813 PyObject *resultobj;
29814 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29815 int result;
29816 PyObject * obj0 = 0 ;
29817 char *kwnames[] = {
29818 (char *) "self", NULL
29819 };
29820
29821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29823 if (SWIG_arg_fail(1)) SWIG_fail;
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29827
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 {
29832 resultobj = SWIG_From_int((int)(result));
29833 }
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj;
29842 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29843 int result;
29844 PyObject * obj0 = 0 ;
29845 char *kwnames[] = {
29846 (char *) "self", NULL
29847 };
29848
29849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29851 if (SWIG_arg_fail(1)) SWIG_fail;
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 {
29860 resultobj = SWIG_From_int((int)(result));
29861 }
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj;
29870 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29871 int result;
29872 PyObject * obj0 = 0 ;
29873 char *kwnames[] = {
29874 (char *) "self", NULL
29875 };
29876
29877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29879 if (SWIG_arg_fail(1)) SWIG_fail;
29880 {
29881 PyThreadState* __tstate = wxPyBeginAllowThreads();
29882 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29883
29884 wxPyEndAllowThreads(__tstate);
29885 if (PyErr_Occurred()) SWIG_fail;
29886 }
29887 {
29888 resultobj = SWIG_From_int((int)(result));
29889 }
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29897 PyObject *resultobj;
29898 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29899 bool result;
29900 PyObject * obj0 = 0 ;
29901 char *kwnames[] = {
29902 (char *) "self", NULL
29903 };
29904
29905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) 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 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29911
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 {
29916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29917 }
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj;
29926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29927 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29928 bool result;
29929 PyObject * obj0 = 0 ;
29930 PyObject * obj1 = 0 ;
29931 char *kwnames[] = {
29932 (char *) "self",(char *) "other", NULL
29933 };
29934
29935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29937 if (SWIG_arg_fail(1)) SWIG_fail;
29938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29939 if (SWIG_arg_fail(2)) SWIG_fail;
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 {
29948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29949 }
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
29957 PyObject *resultobj;
29958 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29959 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29960 bool result;
29961 PyObject * obj0 = 0 ;
29962 PyObject * obj1 = 0 ;
29963 char *kwnames[] = {
29964 (char *) "self",(char *) "other", NULL
29965 };
29966
29967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
29968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29969 if (SWIG_arg_fail(1)) SWIG_fail;
29970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29971 if (SWIG_arg_fail(2)) SWIG_fail;
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
29975
29976 wxPyEndAllowThreads(__tstate);
29977 if (PyErr_Occurred()) SWIG_fail;
29978 }
29979 {
29980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29981 }
29982 return resultobj;
29983 fail:
29984 return NULL;
29985 }
29986
29987
29988 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
29989 PyObject *resultobj;
29990 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29991 int arg2 ;
29992 PyObject * obj0 = 0 ;
29993 PyObject * obj1 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self",(char *) "w", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 {
30002 arg2 = (int)(SWIG_As_int(obj1));
30003 if (SWIG_arg_fail(2)) SWIG_fail;
30004 }
30005 if (arg1) (arg1)->w = arg2;
30006
30007 Py_INCREF(Py_None); resultobj = Py_None;
30008 return resultobj;
30009 fail:
30010 return NULL;
30011 }
30012
30013
30014 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30015 PyObject *resultobj;
30016 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30017 int result;
30018 PyObject * obj0 = 0 ;
30019 char *kwnames[] = {
30020 (char *) "self", NULL
30021 };
30022
30023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30025 if (SWIG_arg_fail(1)) SWIG_fail;
30026 result = (int) ((arg1)->w);
30027
30028 {
30029 resultobj = SWIG_From_int((int)(result));
30030 }
30031 return resultobj;
30032 fail:
30033 return NULL;
30034 }
30035
30036
30037 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30038 PyObject *resultobj;
30039 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30040 int arg2 ;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043 char *kwnames[] = {
30044 (char *) "self",(char *) "h", NULL
30045 };
30046
30047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30049 if (SWIG_arg_fail(1)) SWIG_fail;
30050 {
30051 arg2 = (int)(SWIG_As_int(obj1));
30052 if (SWIG_arg_fail(2)) SWIG_fail;
30053 }
30054 if (arg1) (arg1)->h = arg2;
30055
30056 Py_INCREF(Py_None); resultobj = Py_None;
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj;
30065 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30066 int result;
30067 PyObject * obj0 = 0 ;
30068 char *kwnames[] = {
30069 (char *) "self", NULL
30070 };
30071
30072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30074 if (SWIG_arg_fail(1)) SWIG_fail;
30075 result = (int) ((arg1)->h);
30076
30077 {
30078 resultobj = SWIG_From_int((int)(result));
30079 }
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30089 int arg2 ;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char *kwnames[] = {
30093 (char *) "self",(char *) "bpp", NULL
30094 };
30095
30096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30098 if (SWIG_arg_fail(1)) SWIG_fail;
30099 {
30100 arg2 = (int)(SWIG_As_int(obj1));
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 }
30103 if (arg1) (arg1)->bpp = arg2;
30104
30105 Py_INCREF(Py_None); resultobj = Py_None;
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj;
30114 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30115 int result;
30116 PyObject * obj0 = 0 ;
30117 char *kwnames[] = {
30118 (char *) "self", NULL
30119 };
30120
30121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30123 if (SWIG_arg_fail(1)) SWIG_fail;
30124 result = (int) ((arg1)->bpp);
30125
30126 {
30127 resultobj = SWIG_From_int((int)(result));
30128 }
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30136 PyObject *resultobj;
30137 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30138 int arg2 ;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char *kwnames[] = {
30142 (char *) "self",(char *) "refresh", NULL
30143 };
30144
30145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30147 if (SWIG_arg_fail(1)) SWIG_fail;
30148 {
30149 arg2 = (int)(SWIG_As_int(obj1));
30150 if (SWIG_arg_fail(2)) SWIG_fail;
30151 }
30152 if (arg1) (arg1)->refresh = arg2;
30153
30154 Py_INCREF(Py_None); resultobj = Py_None;
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj;
30163 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30164 int result;
30165 PyObject * obj0 = 0 ;
30166 char *kwnames[] = {
30167 (char *) "self", NULL
30168 };
30169
30170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30172 if (SWIG_arg_fail(1)) SWIG_fail;
30173 result = (int) ((arg1)->refresh);
30174
30175 {
30176 resultobj = SWIG_From_int((int)(result));
30177 }
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30185 PyObject *obj;
30186 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30187 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30188 Py_INCREF(obj);
30189 return Py_BuildValue((char *)"");
30190 }
30191 static int _wrap_DefaultVideoMode_set(PyObject *) {
30192 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30193 return 1;
30194 }
30195
30196
30197 static PyObject *_wrap_DefaultVideoMode_get(void) {
30198 PyObject *pyobj;
30199
30200 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30201 return pyobj;
30202 }
30203
30204
30205 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj;
30207 size_t arg1 = (size_t) 0 ;
30208 wxDisplay *result;
30209 PyObject * obj0 = 0 ;
30210 char *kwnames[] = {
30211 (char *) "index", NULL
30212 };
30213
30214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30215 if (obj0) {
30216 {
30217 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30218 if (SWIG_arg_fail(1)) SWIG_fail;
30219 }
30220 }
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 result = (wxDisplay *)new wxDisplay(arg1);
30224
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj;
30237 wxDisplay *arg1 = (wxDisplay *) 0 ;
30238 PyObject * obj0 = 0 ;
30239 char *kwnames[] = {
30240 (char *) "self", NULL
30241 };
30242
30243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30245 if (SWIG_arg_fail(1)) SWIG_fail;
30246 {
30247 PyThreadState* __tstate = wxPyBeginAllowThreads();
30248 delete arg1;
30249
30250 wxPyEndAllowThreads(__tstate);
30251 if (PyErr_Occurred()) SWIG_fail;
30252 }
30253 Py_INCREF(Py_None); resultobj = Py_None;
30254 return resultobj;
30255 fail:
30256 return NULL;
30257 }
30258
30259
30260 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30261 PyObject *resultobj;
30262 size_t result;
30263 char *kwnames[] = {
30264 NULL
30265 };
30266
30267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 result = (size_t)wxDisplay::GetCount();
30271
30272 wxPyEndAllowThreads(__tstate);
30273 if (PyErr_Occurred()) SWIG_fail;
30274 }
30275 {
30276 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30277 }
30278 return resultobj;
30279 fail:
30280 return NULL;
30281 }
30282
30283
30284 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30285 PyObject *resultobj;
30286 wxPoint *arg1 = 0 ;
30287 int result;
30288 wxPoint temp1 ;
30289 PyObject * obj0 = 0 ;
30290 char *kwnames[] = {
30291 (char *) "pt", NULL
30292 };
30293
30294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30295 {
30296 arg1 = &temp1;
30297 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30298 }
30299 {
30300 PyThreadState* __tstate = wxPyBeginAllowThreads();
30301 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30302
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 {
30307 resultobj = SWIG_From_int((int)(result));
30308 }
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj;
30317 wxWindow *arg1 = (wxWindow *) 0 ;
30318 int result;
30319 PyObject * obj0 = 0 ;
30320 char *kwnames[] = {
30321 (char *) "window", NULL
30322 };
30323
30324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30326 if (SWIG_arg_fail(1)) SWIG_fail;
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 result = (int)Display_GetFromWindow(arg1);
30330
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 {
30335 resultobj = SWIG_From_int((int)(result));
30336 }
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj;
30345 wxDisplay *arg1 = (wxDisplay *) 0 ;
30346 bool result;
30347 PyObject * obj0 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "self", NULL
30350 };
30351
30352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30354 if (SWIG_arg_fail(1)) SWIG_fail;
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = (bool)((wxDisplay const *)arg1)->IsOk();
30358
30359 wxPyEndAllowThreads(__tstate);
30360 if (PyErr_Occurred()) SWIG_fail;
30361 }
30362 {
30363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30364 }
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxDisplay *arg1 = (wxDisplay *) 0 ;
30374 wxRect result;
30375 PyObject * obj0 = 0 ;
30376 char *kwnames[] = {
30377 (char *) "self", NULL
30378 };
30379
30380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",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)->GetGeometry();
30386
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 {
30391 wxRect * resultptr;
30392 resultptr = new wxRect((wxRect &)(result));
30393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30394 }
30395 return resultobj;
30396 fail:
30397 return NULL;
30398 }
30399
30400
30401 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30402 PyObject *resultobj;
30403 wxDisplay *arg1 = (wxDisplay *) 0 ;
30404 wxString result;
30405 PyObject * obj0 = 0 ;
30406 char *kwnames[] = {
30407 (char *) "self", NULL
30408 };
30409
30410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30412 if (SWIG_arg_fail(1)) SWIG_fail;
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = ((wxDisplay const *)arg1)->GetName();
30416
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 {
30421 #if wxUSE_UNICODE
30422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30423 #else
30424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30425 #endif
30426 }
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30434 PyObject *resultobj;
30435 wxDisplay *arg1 = (wxDisplay *) 0 ;
30436 bool result;
30437 PyObject * obj0 = 0 ;
30438 char *kwnames[] = {
30439 (char *) "self", NULL
30440 };
30441
30442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30444 if (SWIG_arg_fail(1)) SWIG_fail;
30445 {
30446 PyThreadState* __tstate = wxPyBeginAllowThreads();
30447 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30448
30449 wxPyEndAllowThreads(__tstate);
30450 if (PyErr_Occurred()) SWIG_fail;
30451 }
30452 {
30453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30454 }
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30462 PyObject *resultobj;
30463 wxDisplay *arg1 = (wxDisplay *) 0 ;
30464 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30465 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30466 PyObject *result;
30467 PyObject * obj0 = 0 ;
30468 PyObject * obj1 = 0 ;
30469 char *kwnames[] = {
30470 (char *) "self",(char *) "mode", NULL
30471 };
30472
30473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30475 if (SWIG_arg_fail(1)) SWIG_fail;
30476 if (obj1) {
30477 {
30478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30479 if (SWIG_arg_fail(2)) SWIG_fail;
30480 if (arg2 == NULL) {
30481 SWIG_null_ref("wxVideoMode");
30482 }
30483 if (SWIG_arg_fail(2)) SWIG_fail;
30484 }
30485 }
30486 {
30487 PyThreadState* __tstate = wxPyBeginAllowThreads();
30488 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30489
30490 wxPyEndAllowThreads(__tstate);
30491 if (PyErr_Occurred()) SWIG_fail;
30492 }
30493 resultobj = result;
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj;
30502 wxDisplay *arg1 = (wxDisplay *) 0 ;
30503 wxVideoMode result;
30504 PyObject * obj0 = 0 ;
30505 char *kwnames[] = {
30506 (char *) "self", NULL
30507 };
30508
30509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30511 if (SWIG_arg_fail(1)) SWIG_fail;
30512 {
30513 PyThreadState* __tstate = wxPyBeginAllowThreads();
30514 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30515
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 {
30520 wxVideoMode * resultptr;
30521 resultptr = new wxVideoMode((wxVideoMode &)(result));
30522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30523 }
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30531 PyObject *resultobj;
30532 wxDisplay *arg1 = (wxDisplay *) 0 ;
30533 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30534 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30535 bool result;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 char *kwnames[] = {
30539 (char *) "self",(char *) "mode", NULL
30540 };
30541
30542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30544 if (SWIG_arg_fail(1)) SWIG_fail;
30545 if (obj1) {
30546 {
30547 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30548 if (SWIG_arg_fail(2)) SWIG_fail;
30549 if (arg2 == NULL) {
30550 SWIG_null_ref("wxVideoMode");
30551 }
30552 if (SWIG_arg_fail(2)) SWIG_fail;
30553 }
30554 }
30555 {
30556 PyThreadState* __tstate = wxPyBeginAllowThreads();
30557 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30558
30559 wxPyEndAllowThreads(__tstate);
30560 if (PyErr_Occurred()) SWIG_fail;
30561 }
30562 {
30563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30564 }
30565 return resultobj;
30566 fail:
30567 return NULL;
30568 }
30569
30570
30571 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30572 PyObject *resultobj;
30573 wxDisplay *arg1 = (wxDisplay *) 0 ;
30574 PyObject * obj0 = 0 ;
30575 char *kwnames[] = {
30576 (char *) "self", NULL
30577 };
30578
30579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30581 if (SWIG_arg_fail(1)) SWIG_fail;
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 (arg1)->ResetMode();
30585
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 Py_INCREF(Py_None); resultobj = Py_None;
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30597 PyObject *obj;
30598 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30599 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30600 Py_INCREF(obj);
30601 return Py_BuildValue((char *)"");
30602 }
30603 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30604 PyObject *resultobj;
30605 wxStandardPaths *result;
30606 char *kwnames[] = {
30607 NULL
30608 };
30609
30610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30611 {
30612 PyThreadState* __tstate = wxPyBeginAllowThreads();
30613 result = (wxStandardPaths *)StandardPaths_Get();
30614
30615 wxPyEndAllowThreads(__tstate);
30616 if (PyErr_Occurred()) SWIG_fail;
30617 }
30618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30619 return resultobj;
30620 fail:
30621 return NULL;
30622 }
30623
30624
30625 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30626 PyObject *resultobj;
30627 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30628 wxString result;
30629 PyObject * obj0 = 0 ;
30630 char *kwnames[] = {
30631 (char *) "self", NULL
30632 };
30633
30634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30636 if (SWIG_arg_fail(1)) SWIG_fail;
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30640
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 {
30645 #if wxUSE_UNICODE
30646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30647 #else
30648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30649 #endif
30650 }
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj;
30659 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30660 wxString result;
30661 PyObject * obj0 = 0 ;
30662 char *kwnames[] = {
30663 (char *) "self", NULL
30664 };
30665
30666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30668 if (SWIG_arg_fail(1)) SWIG_fail;
30669 {
30670 PyThreadState* __tstate = wxPyBeginAllowThreads();
30671 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30672
30673 wxPyEndAllowThreads(__tstate);
30674 if (PyErr_Occurred()) SWIG_fail;
30675 }
30676 {
30677 #if wxUSE_UNICODE
30678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30679 #else
30680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30681 #endif
30682 }
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj;
30691 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30692 wxString result;
30693 PyObject * obj0 = 0 ;
30694 char *kwnames[] = {
30695 (char *) "self", NULL
30696 };
30697
30698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30700 if (SWIG_arg_fail(1)) SWIG_fail;
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 {
30709 #if wxUSE_UNICODE
30710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30711 #else
30712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30713 #endif
30714 }
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30722 PyObject *resultobj;
30723 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30724 wxString result;
30725 PyObject * obj0 = 0 ;
30726 char *kwnames[] = {
30727 (char *) "self", NULL
30728 };
30729
30730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30732 if (SWIG_arg_fail(1)) SWIG_fail;
30733 {
30734 PyThreadState* __tstate = wxPyBeginAllowThreads();
30735 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30736
30737 wxPyEndAllowThreads(__tstate);
30738 if (PyErr_Occurred()) SWIG_fail;
30739 }
30740 {
30741 #if wxUSE_UNICODE
30742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30743 #else
30744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30745 #endif
30746 }
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30754 PyObject *resultobj;
30755 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30756 wxString result;
30757 PyObject * obj0 = 0 ;
30758 char *kwnames[] = {
30759 (char *) "self", NULL
30760 };
30761
30762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30764 if (SWIG_arg_fail(1)) SWIG_fail;
30765 {
30766 PyThreadState* __tstate = wxPyBeginAllowThreads();
30767 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30768
30769 wxPyEndAllowThreads(__tstate);
30770 if (PyErr_Occurred()) SWIG_fail;
30771 }
30772 {
30773 #if wxUSE_UNICODE
30774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30775 #else
30776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30777 #endif
30778 }
30779 return resultobj;
30780 fail:
30781 return NULL;
30782 }
30783
30784
30785 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30786 PyObject *resultobj;
30787 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30788 wxString result;
30789 PyObject * obj0 = 0 ;
30790 char *kwnames[] = {
30791 (char *) "self", NULL
30792 };
30793
30794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30796 if (SWIG_arg_fail(1)) SWIG_fail;
30797 {
30798 PyThreadState* __tstate = wxPyBeginAllowThreads();
30799 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30800
30801 wxPyEndAllowThreads(__tstate);
30802 if (PyErr_Occurred()) SWIG_fail;
30803 }
30804 {
30805 #if wxUSE_UNICODE
30806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30807 #else
30808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30809 #endif
30810 }
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30818 PyObject *resultobj;
30819 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30820 wxString result;
30821 PyObject * obj0 = 0 ;
30822 char *kwnames[] = {
30823 (char *) "self", NULL
30824 };
30825
30826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30828 if (SWIG_arg_fail(1)) SWIG_fail;
30829 {
30830 PyThreadState* __tstate = wxPyBeginAllowThreads();
30831 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30832
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 {
30837 #if wxUSE_UNICODE
30838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30839 #else
30840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30841 #endif
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30850 PyObject *resultobj;
30851 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30852 wxString *arg2 = 0 ;
30853 bool temp2 = false ;
30854 PyObject * obj0 = 0 ;
30855 PyObject * obj1 = 0 ;
30856 char *kwnames[] = {
30857 (char *) "self",(char *) "prefix", NULL
30858 };
30859
30860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30862 if (SWIG_arg_fail(1)) SWIG_fail;
30863 {
30864 arg2 = wxString_in_helper(obj1);
30865 if (arg2 == NULL) SWIG_fail;
30866 temp2 = true;
30867 }
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 (arg1)->SetInstallPrefix((wxString const &)*arg2);
30871
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 Py_INCREF(Py_None); resultobj = Py_None;
30876 {
30877 if (temp2)
30878 delete arg2;
30879 }
30880 return resultobj;
30881 fail:
30882 {
30883 if (temp2)
30884 delete arg2;
30885 }
30886 return NULL;
30887 }
30888
30889
30890 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30891 PyObject *resultobj;
30892 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30893 wxString result;
30894 PyObject * obj0 = 0 ;
30895 char *kwnames[] = {
30896 (char *) "self", NULL
30897 };
30898
30899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30901 if (SWIG_arg_fail(1)) SWIG_fail;
30902 {
30903 PyThreadState* __tstate = wxPyBeginAllowThreads();
30904 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
30905
30906 wxPyEndAllowThreads(__tstate);
30907 if (PyErr_Occurred()) SWIG_fail;
30908 }
30909 {
30910 #if wxUSE_UNICODE
30911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30912 #else
30913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30914 #endif
30915 }
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30923 PyObject *obj;
30924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30925 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30926 Py_INCREF(obj);
30927 return Py_BuildValue((char *)"");
30928 }
30929 static PyMethodDef SwigMethods[] = {
30930 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30931 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30932 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30933 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30934 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30935 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30936 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
30937 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
30938 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30939 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30940 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30941 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30942 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
30943 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
30944 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
30945 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
30946 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
30947 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
30948 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30949 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30950 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
30951 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30952 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
30953 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
30954 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
30955 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
30956 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
30957 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
30958 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
30959 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
30960 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
30961 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
30962 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
30963 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
30964 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
30965 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
30966 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
30967 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
30968 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
30969 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
30970 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
30971 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
30972 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
30973 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
30974 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
30975 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
30976 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30977 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30978 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30979 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30980 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30981 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30982 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
30983 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
30984 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
30985 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30986 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
30987 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30989 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
30990 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
30991 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
30992 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
30993 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
30994 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
30999 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31000 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31001 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31007 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31008 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31014 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31016 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31022 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31034 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31037 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31038 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31039 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31040 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31043 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31044 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31046 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31049 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31055 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31063 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31064 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31069 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31074 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31075 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31077 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31080 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31083 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31091 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31094 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31095 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31097 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31098 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31100 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31101 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31104 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31125 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31127 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31129 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31131 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31133 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31135 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31137 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31138 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31144 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31150 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31158 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31162 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31164 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31165 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31168 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31171 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31182 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31188 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31190 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31196 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31237 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31243 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31255 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31261 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31265 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31271 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31281 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31297 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31311 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31320 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31363 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31366 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31369 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31373 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31466 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31467 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31468 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31469 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31486 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31531 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31565 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31573 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31574 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31579 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31588 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31595 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31598 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31601 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31606 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31609 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31613 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31616 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31620 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31621 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31625 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31629 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31631 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31641 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31652 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31660 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31668 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31682 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31686 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31704 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31718 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31729 { NULL, NULL, 0, NULL }
31730 };
31731
31732
31733 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31734
31735 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31737 }
31738 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31739 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31740 }
31741 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31742 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31743 }
31744 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31745 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31746 }
31747 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31748 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31749 }
31750 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31751 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31752 }
31753 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31754 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31755 }
31756 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31757 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31758 }
31759 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31760 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31761 }
31762 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31763 return (void *)((wxEvent *) ((wxPyEvent *) x));
31764 }
31765 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31767 }
31768 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31769 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31770 }
31771 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31772 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31773 }
31774 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31775 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31776 }
31777 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31778 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31779 }
31780 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31781 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31782 }
31783 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31784 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31785 }
31786 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31787 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31788 }
31789 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31790 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31791 }
31792 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31793 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31794 }
31795 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
31796 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
31797 }
31798 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31799 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31800 }
31801 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31802 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31803 }
31804 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31805 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31806 }
31807 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31808 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31809 }
31810 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31811 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31812 }
31813 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31814 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31815 }
31816 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31817 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31818 }
31819 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31820 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31821 }
31822 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31823 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31824 }
31825 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31826 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31827 }
31828 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31829 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31830 }
31831 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31832 return (void *)((wxEvent *) ((wxShowEvent *) x));
31833 }
31834 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31835 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31836 }
31837 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31838 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31839 }
31840 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31841 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31842 }
31843 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31844 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31845 }
31846 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31847 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31848 }
31849 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31850 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31851 }
31852 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31853 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31854 }
31855 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31856 return (void *)((wxConfigBase *) ((wxConfig *) x));
31857 }
31858 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31859 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31860 }
31861 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31862 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31863 }
31864 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31865 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31866 }
31867 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31868 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31869 }
31870 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31871 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31872 }
31873 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31874 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31875 }
31876 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31877 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31878 }
31879 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31880 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31881 }
31882 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31883 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31884 }
31885 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31886 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31887 }
31888 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31889 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31890 }
31891 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31892 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31893 }
31894 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31895 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31896 }
31897 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31898 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31899 }
31900 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31901 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31902 }
31903 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31904 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31905 }
31906 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31907 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31908 }
31909 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31910 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31911 }
31912 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31913 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31914 }
31915 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31916 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31917 }
31918 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31919 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31920 }
31921 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31922 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31923 }
31924 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31925 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31926 }
31927 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31928 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31929 }
31930 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31931 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31932 }
31933 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31934 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31935 }
31936 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31937 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
31938 }
31939 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
31940 return (void *)((wxEvtHandler *) ((wxValidator *) x));
31941 }
31942 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
31943 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
31944 }
31945 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
31946 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
31947 }
31948 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
31949 return (void *)((wxEvtHandler *) ((wxMenu *) x));
31950 }
31951 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
31952 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
31953 }
31954 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
31955 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
31956 }
31957 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
31958 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
31959 }
31960 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
31961 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
31962 }
31963 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
31964 return (void *)((wxObject *) ((wxSizerItem *) x));
31965 }
31966 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
31967 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
31968 }
31969 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
31970 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
31971 }
31972 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
31973 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
31974 }
31975 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
31976 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
31977 }
31978 static void *_p_wxSizerTo_p_wxObject(void *x) {
31979 return (void *)((wxObject *) ((wxSizer *) x));
31980 }
31981 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
31982 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
31983 }
31984 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
31985 return (void *)((wxObject *) ((wxFileHistory *) x));
31986 }
31987 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
31988 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
31989 }
31990 static void *_p_wxEventTo_p_wxObject(void *x) {
31991 return (void *)((wxObject *) ((wxEvent *) x));
31992 }
31993 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
31994 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
31995 }
31996 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
31997 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
31998 }
31999 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32000 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32001 }
32002 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32003 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32004 }
32005 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32006 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32007 }
32008 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32009 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32010 }
32011 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32012 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32013 }
32014 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32015 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32016 }
32017 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32018 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32019 }
32020 static void *_p_wxControlTo_p_wxObject(void *x) {
32021 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32022 }
32023 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32024 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32025 }
32026 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32027 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32028 }
32029 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32030 return (void *)((wxObject *) ((wxFSFile *) x));
32031 }
32032 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32033 return (void *)((wxObject *) ((wxClipboard *) x));
32034 }
32035 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32036 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32037 }
32038 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32039 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32040 }
32041 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32042 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32043 }
32044 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32045 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32046 }
32047 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32048 return (void *)((wxObject *) ((wxToolTip *) x));
32049 }
32050 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32051 return (void *)((wxObject *) ((wxMenuItem *) x));
32052 }
32053 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32054 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32055 }
32056 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32057 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32058 }
32059 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32060 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32061 }
32062 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32063 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32064 }
32065 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32066 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32067 }
32068 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32069 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32070 }
32071 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32072 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32073 }
32074 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32075 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32076 }
32077 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32078 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32079 }
32080 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32081 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32082 }
32083 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32084 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32085 }
32086 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32087 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32088 }
32089 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32090 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32091 }
32092 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32093 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32094 }
32095 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32096 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32097 }
32098 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32099 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32100 }
32101 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32102 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32103 }
32104 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32105 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32106 }
32107 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32108 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32109 }
32110 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32111 return (void *)((wxObject *) ((wxImageHandler *) x));
32112 }
32113 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32114 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32115 }
32116 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32117 return (void *)((wxObject *) ((wxEvtHandler *) x));
32118 }
32119 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32120 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32121 }
32122 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32123 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32124 }
32125 static void *_p_wxImageTo_p_wxObject(void *x) {
32126 return (void *)((wxObject *) ((wxImage *) x));
32127 }
32128 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32129 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32130 }
32131 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32132 return (void *)((wxObject *) ((wxSystemOptions *) x));
32133 }
32134 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32135 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32136 }
32137 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32138 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32139 }
32140 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32141 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32142 }
32143 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32144 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32145 }
32146 static void *_p_wxWindowTo_p_wxObject(void *x) {
32147 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32148 }
32149 static void *_p_wxMenuTo_p_wxObject(void *x) {
32150 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32151 }
32152 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32153 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32154 }
32155 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32156 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32157 }
32158 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32159 return (void *)((wxObject *) ((wxFileSystem *) x));
32160 }
32161 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32162 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32163 }
32164 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32165 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32166 }
32167 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32168 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32169 }
32170 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32171 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32172 }
32173 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32174 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32175 }
32176 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32177 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32178 }
32179 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32180 return (void *)((wxObject *) ((wxBusyInfo *) x));
32181 }
32182 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32183 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32184 }
32185 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32186 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32187 }
32188 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32189 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32190 }
32191 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32192 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32193 }
32194 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32195 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32196 }
32197 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32198 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32199 }
32200 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32201 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32202 }
32203 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32204 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32205 }
32206 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32207 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32208 }
32209 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32210 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32211 }
32212 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32213 return (void *)((wxLog *) ((wxLogStderr *) x));
32214 }
32215 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32216 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32217 }
32218 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32219 return (void *)((wxLog *) ((wxLogWindow *) x));
32220 }
32221 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32222 return (void *)((wxLog *) ((wxLogChain *) x));
32223 }
32224 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32225 return (void *)((wxLog *) ((wxLogGui *) x));
32226 }
32227 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32228 return (void *)((wxLog *) ((wxPyLog *) x));
32229 }
32230 static void *_p_wxControlTo_p_wxWindow(void *x) {
32231 return (void *)((wxWindow *) ((wxControl *) x));
32232 }
32233 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32234 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32235 }
32236 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32237 return (void *)((wxWindow *) ((wxMenuBar *) x));
32238 }
32239 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32240 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32241 }
32242 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32243 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32244 }
32245 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}};
32246 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}};
32247 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}};
32248 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}};
32249 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}};
32250 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32251 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}};
32252 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}};
32253 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}};
32254 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}};
32255 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}};
32256 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}};
32257 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}};
32258 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}};
32259 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}};
32260 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}};
32261 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}};
32262 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}};
32263 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}};
32264 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}};
32265 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}};
32266 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}};
32267 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}};
32268 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}};
32269 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}};
32270 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}};
32271 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}};
32272 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}};
32273 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}};
32274 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}};
32275 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}};
32276 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}};
32277 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}};
32278 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}};
32279 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}};
32280 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}};
32281 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}};
32282 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}};
32283 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}};
32284 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}};
32285 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}};
32286 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}};
32287 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}};
32288 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}};
32289 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}};
32290 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}};
32291 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}};
32292 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}};
32293 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}};
32294 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}};
32295 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}};
32296 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}};
32297 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}};
32298 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}};
32299 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}};
32300 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}};
32301 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}};
32302 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}};
32303 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}};
32304 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}};
32305 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}};
32306 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}};
32307 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}};
32308 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}};
32309 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}};
32310 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}};
32311 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}};
32312 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}};
32313 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}};
32314 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32315 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}};
32316 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}};
32317 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}};
32318 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}};
32319 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}};
32320 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}};
32321 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}};
32322 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}};
32323 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}};
32324 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}};
32325 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}};
32326 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}};
32327 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}};
32328 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}};
32329 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}};
32330 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}};
32331 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}};
32332 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}};
32333 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}};
32334 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}};
32335 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}};
32336 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}};
32337 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}};
32338 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}};
32339 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}};
32340
32341 static swig_type_info *swig_types_initial[] = {
32342 _swigt__p_wxLogChain,
32343 _swigt__p_wxMutexGuiLocker,
32344 _swigt__p_wxFileHistory,
32345 _swigt__p_wxLog,
32346 _swigt__p_wxMenu,
32347 _swigt__p_wxEvent,
32348 _swigt__p_wxDateTime__TimeZone,
32349 _swigt__p_wxConfigBase,
32350 _swigt__p_wxDisplay,
32351 _swigt__p_wxFileType,
32352 _swigt__p_wxLogGui,
32353 _swigt__p_wxFont,
32354 _swigt__p_wxDataFormat,
32355 _swigt__p_wxTimerEvent,
32356 _swigt__p_wxCaret,
32357 _swigt__ptrdiff_t,
32358 _swigt__std__ptrdiff_t,
32359 _swigt__p_int,
32360 _swigt__p_wxSize,
32361 _swigt__p_wxClipboard,
32362 _swigt__p_wxStopWatch,
32363 _swigt__p_wxClipboardLocker,
32364 _swigt__p_wxIcon,
32365 _swigt__p_wxLogStderr,
32366 _swigt__p_wxLogTextCtrl,
32367 _swigt__p_wxTextCtrl,
32368 _swigt__p_wxBusyCursor,
32369 _swigt__p_wxBitmapDataObject,
32370 _swigt__p_wxTextDataObject,
32371 _swigt__p_wxDataObject,
32372 _swigt__p_wxPyTextDataObject,
32373 _swigt__p_wxPyBitmapDataObject,
32374 _swigt__p_wxFileDataObject,
32375 _swigt__p_wxCustomDataObject,
32376 _swigt__p_wxURLDataObject,
32377 _swigt__p_wxMetafileDataObject,
32378 _swigt__p_wxSound,
32379 _swigt__p_wxTimerRunner,
32380 _swigt__p_wxLogWindow,
32381 _swigt__p_wxTimeSpan,
32382 _swigt__p_wxArrayString,
32383 _swigt__p_wxWindowDisabler,
32384 _swigt__p_form_ops_t,
32385 _swigt__p_wxToolTip,
32386 _swigt__p_wxDataObjectComposite,
32387 _swigt__p_wxFileConfig,
32388 _swigt__p_wxSystemSettings,
32389 _swigt__p_wxVideoMode,
32390 _swigt__p_wxDataObjectSimple,
32391 _swigt__p_wxPyDataObjectSimple,
32392 _swigt__p_wxDuplexMode,
32393 _swigt__p_wxEvtHandler,
32394 _swigt__p_wxRect,
32395 _swigt__p_char,
32396 _swigt__p_wxSingleInstanceChecker,
32397 _swigt__p_wxStandardPaths,
32398 _swigt__p_wxFileTypeInfo,
32399 _swigt__p_wxFrame,
32400 _swigt__p_wxTimer,
32401 _swigt__p_wxPaperSize,
32402 _swigt__p_wxMimeTypesManager,
32403 _swigt__p_wxPyArtProvider,
32404 _swigt__p_wxPyTipProvider,
32405 _swigt__p_wxTipProvider,
32406 _swigt__p_wxJoystick,
32407 _swigt__p_wxSystemOptions,
32408 _swigt__p_wxPoint,
32409 _swigt__p_wxJoystickEvent,
32410 _swigt__p_wxCursor,
32411 _swigt__p_wxObject,
32412 _swigt__p_wxOutputStream,
32413 _swigt__p_wxDateTime,
32414 _swigt__p_wxPyDropSource,
32415 _swigt__p_unsigned_long,
32416 _swigt__p_wxKillError,
32417 _swigt__p_wxWindow,
32418 _swigt__p_wxString,
32419 _swigt__p_wxPyProcess,
32420 _swigt__p_wxBitmap,
32421 _swigt__p_wxConfig,
32422 _swigt__unsigned_int,
32423 _swigt__p_unsigned_int,
32424 _swigt__p_unsigned_char,
32425 _swigt__p_wxChar,
32426 _swigt__p_wxBusyInfo,
32427 _swigt__p_wxPyDropTarget,
32428 _swigt__p_wxPyTextDropTarget,
32429 _swigt__p_wxPyFileDropTarget,
32430 _swigt__p_wxProcessEvent,
32431 _swigt__p_wxPyLog,
32432 _swigt__p_wxLogNull,
32433 _swigt__p_wxColour,
32434 _swigt__p_wxPyTimer,
32435 _swigt__p_wxConfigPathChanger,
32436 _swigt__p_wxDateSpan,
32437 0
32438 };
32439
32440
32441 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32442
32443 static swig_const_info swig_const_table[] = {
32444 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32445 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32446 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32447 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32448 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32449 {0, 0, 0, 0.0, 0, 0}};
32450
32451 #ifdef __cplusplus
32452 }
32453 #endif
32454
32455
32456 #ifdef __cplusplus
32457 extern "C" {
32458 #endif
32459
32460 /* Python-specific SWIG API */
32461 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32462 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32463 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32464
32465 /* -----------------------------------------------------------------------------
32466 * global variable support code.
32467 * ----------------------------------------------------------------------------- */
32468
32469 typedef struct swig_globalvar {
32470 char *name; /* Name of global variable */
32471 PyObject *(*get_attr)(); /* Return the current value */
32472 int (*set_attr)(PyObject *); /* Set the value */
32473 struct swig_globalvar *next;
32474 } swig_globalvar;
32475
32476 typedef struct swig_varlinkobject {
32477 PyObject_HEAD
32478 swig_globalvar *vars;
32479 } swig_varlinkobject;
32480
32481 static PyObject *
32482 swig_varlink_repr(swig_varlinkobject *v) {
32483 v = v;
32484 return PyString_FromString("<Swig global variables>");
32485 }
32486
32487 static int
32488 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32489 swig_globalvar *var;
32490 flags = flags;
32491 fprintf(fp,"Swig global variables { ");
32492 for (var = v->vars; var; var=var->next) {
32493 fprintf(fp,"%s", var->name);
32494 if (var->next) fprintf(fp,", ");
32495 }
32496 fprintf(fp," }\n");
32497 return 0;
32498 }
32499
32500 static PyObject *
32501 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32502 swig_globalvar *var = v->vars;
32503 while (var) {
32504 if (strcmp(var->name,n) == 0) {
32505 return (*var->get_attr)();
32506 }
32507 var = var->next;
32508 }
32509 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32510 return NULL;
32511 }
32512
32513 static int
32514 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32515 swig_globalvar *var = v->vars;
32516 while (var) {
32517 if (strcmp(var->name,n) == 0) {
32518 return (*var->set_attr)(p);
32519 }
32520 var = var->next;
32521 }
32522 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32523 return 1;
32524 }
32525
32526 static PyTypeObject varlinktype = {
32527 PyObject_HEAD_INIT(0)
32528 0, /* Number of items in variable part (ob_size) */
32529 (char *)"swigvarlink", /* Type name (tp_name) */
32530 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32531 0, /* Itemsize (tp_itemsize) */
32532 0, /* Deallocator (tp_dealloc) */
32533 (printfunc) swig_varlink_print, /* Print (tp_print) */
32534 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32535 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32536 0, /* tp_compare */
32537 (reprfunc) swig_varlink_repr, /* tp_repr */
32538 0, /* tp_as_number */
32539 0, /* tp_as_sequence */
32540 0, /* tp_as_mapping */
32541 0, /* tp_hash */
32542 0, /* tp_call */
32543 0, /* tp_str */
32544 0, /* tp_getattro */
32545 0, /* tp_setattro */
32546 0, /* tp_as_buffer */
32547 0, /* tp_flags */
32548 0, /* tp_doc */
32549 #if PY_VERSION_HEX >= 0x02000000
32550 0, /* tp_traverse */
32551 0, /* tp_clear */
32552 #endif
32553 #if PY_VERSION_HEX >= 0x02010000
32554 0, /* tp_richcompare */
32555 0, /* tp_weaklistoffset */
32556 #endif
32557 #if PY_VERSION_HEX >= 0x02020000
32558 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32559 #endif
32560 #if PY_VERSION_HEX >= 0x02030000
32561 0, /* tp_del */
32562 #endif
32563 #ifdef COUNT_ALLOCS
32564 0,0,0,0 /* tp_alloc -> tp_next */
32565 #endif
32566 };
32567
32568 /* Create a variable linking object for use later */
32569 static PyObject *
32570 SWIG_Python_newvarlink(void) {
32571 swig_varlinkobject *result = 0;
32572 result = PyMem_NEW(swig_varlinkobject,1);
32573 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32574 result->ob_type = &varlinktype;
32575 result->vars = 0;
32576 result->ob_refcnt = 0;
32577 Py_XINCREF((PyObject *) result);
32578 return ((PyObject*) result);
32579 }
32580
32581 static void
32582 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32583 swig_varlinkobject *v;
32584 swig_globalvar *gv;
32585 v= (swig_varlinkobject *) p;
32586 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32587 gv->name = (char *) malloc(strlen(name)+1);
32588 strcpy(gv->name,name);
32589 gv->get_attr = get_attr;
32590 gv->set_attr = set_attr;
32591 gv->next = v->vars;
32592 v->vars = gv;
32593 }
32594
32595 /* -----------------------------------------------------------------------------
32596 * constants/methods manipulation
32597 * ----------------------------------------------------------------------------- */
32598
32599 /* Install Constants */
32600 static void
32601 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32602 PyObject *obj = 0;
32603 size_t i;
32604 for (i = 0; constants[i].type; i++) {
32605 switch(constants[i].type) {
32606 case SWIG_PY_INT:
32607 obj = PyInt_FromLong(constants[i].lvalue);
32608 break;
32609 case SWIG_PY_FLOAT:
32610 obj = PyFloat_FromDouble(constants[i].dvalue);
32611 break;
32612 case SWIG_PY_STRING:
32613 if (constants[i].pvalue) {
32614 obj = PyString_FromString((char *) constants[i].pvalue);
32615 } else {
32616 Py_INCREF(Py_None);
32617 obj = Py_None;
32618 }
32619 break;
32620 case SWIG_PY_POINTER:
32621 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32622 break;
32623 case SWIG_PY_BINARY:
32624 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32625 break;
32626 default:
32627 obj = 0;
32628 break;
32629 }
32630 if (obj) {
32631 PyDict_SetItemString(d,constants[i].name,obj);
32632 Py_DECREF(obj);
32633 }
32634 }
32635 }
32636
32637 /* -----------------------------------------------------------------------------*/
32638 /* Fix SwigMethods to carry the callback ptrs when needed */
32639 /* -----------------------------------------------------------------------------*/
32640
32641 static void
32642 SWIG_Python_FixMethods(PyMethodDef *methods,
32643 swig_const_info *const_table,
32644 swig_type_info **types,
32645 swig_type_info **types_initial) {
32646 size_t i;
32647 for (i = 0; methods[i].ml_name; ++i) {
32648 char *c = methods[i].ml_doc;
32649 if (c && (c = strstr(c, "swig_ptr: "))) {
32650 int j;
32651 swig_const_info *ci = 0;
32652 char *name = c + 10;
32653 for (j = 0; const_table[j].type; j++) {
32654 if (strncmp(const_table[j].name, name,
32655 strlen(const_table[j].name)) == 0) {
32656 ci = &(const_table[j]);
32657 break;
32658 }
32659 }
32660 if (ci) {
32661 size_t shift = (ci->ptype) - types;
32662 swig_type_info *ty = types_initial[shift];
32663 size_t ldoc = (c - methods[i].ml_doc);
32664 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32665 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32666 char *buff = ndoc;
32667 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32668 strncpy(buff, methods[i].ml_doc, ldoc);
32669 buff += ldoc;
32670 strncpy(buff, "swig_ptr: ", 10);
32671 buff += 10;
32672 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32673 methods[i].ml_doc = ndoc;
32674 }
32675 }
32676 }
32677 }
32678
32679 /* -----------------------------------------------------------------------------*
32680 * Initialize type list
32681 * -----------------------------------------------------------------------------*/
32682
32683 #if PY_MAJOR_VERSION < 2
32684 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32685 is copied out of Python/modsupport.c in python version 2.3.4 */
32686 static int
32687 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32688 {
32689 PyObject *dict;
32690 if (!PyModule_Check(m)) {
32691 PyErr_SetString(PyExc_TypeError,
32692 "PyModule_AddObject() needs module as first arg");
32693 return -1;
32694 }
32695 if (!o) {
32696 PyErr_SetString(PyExc_TypeError,
32697 "PyModule_AddObject() needs non-NULL value");
32698 return -1;
32699 }
32700
32701 dict = PyModule_GetDict(m);
32702 if (dict == NULL) {
32703 /* Internal error -- modules must have a dict! */
32704 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32705 PyModule_GetName(m));
32706 return -1;
32707 }
32708 if (PyDict_SetItemString(dict, name, o))
32709 return -1;
32710 Py_DECREF(o);
32711 return 0;
32712 }
32713 #endif
32714
32715 static swig_type_info **
32716 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32717 static PyMethodDef swig_empty_runtime_method_table[] = {
32718 {
32719 NULL, NULL, 0, NULL
32720 }
32721 };/* Sentinel */
32722
32723 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32724 swig_empty_runtime_method_table);
32725 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32726 if (pointer && module) {
32727 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32728 }
32729 return type_list_handle;
32730 }
32731
32732 static swig_type_info **
32733 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32734 swig_type_info **type_pointer;
32735
32736 /* first check if module already created */
32737 type_pointer = SWIG_Python_GetTypeListHandle();
32738 if (type_pointer) {
32739 return type_pointer;
32740 } else {
32741 /* create a new module and variable */
32742 return SWIG_Python_SetTypeListHandle(type_list_handle);
32743 }
32744 }
32745
32746 #ifdef __cplusplus
32747 }
32748 #endif
32749
32750 /* -----------------------------------------------------------------------------*
32751 * Partial Init method
32752 * -----------------------------------------------------------------------------*/
32753
32754 #ifdef SWIG_LINK_RUNTIME
32755 #ifdef __cplusplus
32756 extern "C"
32757 #endif
32758 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32759 #endif
32760
32761 #ifdef __cplusplus
32762 extern "C"
32763 #endif
32764 SWIGEXPORT(void) SWIG_init(void) {
32765 static PyObject *SWIG_globals = 0;
32766 static int typeinit = 0;
32767 PyObject *m, *d;
32768 int i;
32769 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32770
32771 /* Fix SwigMethods to carry the callback ptrs when needed */
32772 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32773
32774 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32775 d = PyModule_GetDict(m);
32776
32777 if (!typeinit) {
32778 #ifdef SWIG_LINK_RUNTIME
32779 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32780 #else
32781 # ifndef SWIG_STATIC_RUNTIME
32782 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32783 # endif
32784 #endif
32785 for (i = 0; swig_types_initial[i]; i++) {
32786 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32787 }
32788 typeinit = 1;
32789 }
32790 SWIG_InstallConstants(d,swig_const_table);
32791
32792 {
32793 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32794 }
32795 {
32796 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32797 }
32798 {
32799 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32800 }
32801 {
32802 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32803 }
32804 {
32805 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32806 }
32807 {
32808 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32809 }
32810 {
32811 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32812 }
32813 {
32814 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32815 }
32816 {
32817 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32818 }
32819 {
32820 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32821 }
32822 {
32823 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32824 }
32825 {
32826 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32827 }
32828 {
32829 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32830 }
32831 {
32832 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32833 }
32834 {
32835 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32836 }
32837 {
32838 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32839 }
32840 {
32841 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32842 }
32843 {
32844 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32845 }
32846 {
32847 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32848 }
32849 {
32850 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32851 }
32852 {
32853 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32854 }
32855 {
32856 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32857 }
32858 {
32859 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32860 }
32861 {
32862 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32863 }
32864 {
32865 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32866 }
32867 {
32868 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32869 }
32870 {
32871 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32872 }
32873 {
32874 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32875 }
32876 {
32877 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32878 }
32879 {
32880 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32881 }
32882 {
32883 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32884 }
32885 {
32886 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32887 }
32888 {
32889 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32890 }
32891 {
32892 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32893 }
32894 {
32895 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32896 }
32897 {
32898 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32899 }
32900 {
32901 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32902 }
32903 {
32904 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32905 }
32906 {
32907 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32908 }
32909 {
32910 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32911 }
32912 {
32913 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32914 }
32915 {
32916 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32917 }
32918 {
32919 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32920 }
32921 {
32922 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32923 }
32924 {
32925 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32926 }
32927 {
32928 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32929 }
32930 {
32931 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32932 }
32933 {
32934 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32935 }
32936 {
32937 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32938 }
32939 {
32940 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
32941 }
32942 {
32943 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
32944 }
32945 {
32946 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
32947 }
32948 {
32949 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
32950 }
32951 {
32952 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
32953 }
32954 {
32955 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
32956 }
32957 {
32958 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
32959 }
32960 {
32961 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
32962 }
32963 {
32964 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
32965 }
32966 {
32967 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
32968 }
32969 {
32970 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
32971 }
32972 {
32973 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
32974 }
32975 {
32976 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33064 }
33065 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33066 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33067 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33068 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33069 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33070 {
33071 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33072 }
33073 {
33074 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33075 }
33076 {
33077 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33078 }
33079 {
33080 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33081 }
33082 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33083
33084 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33085
33086 {
33087 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33118 }
33119 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33120 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33121 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33122 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33123 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33124 {
33125 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33126 }
33127 {
33128 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33129 }
33130 {
33131 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33132 }
33133 {
33134 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33135 }
33136 {
33137 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33138 }
33139 {
33140 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33141 }
33142 {
33143 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33144 }
33145 {
33146 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33147 }
33148 {
33149 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33150 }
33151 {
33152 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33153 }
33154 {
33155 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33156 }
33157 {
33158 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33159 }
33160 {
33161 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33162 }
33163 {
33164 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33165 }
33166 {
33167 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33168 }
33169 {
33170 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33171 }
33172 {
33173 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33174 }
33175 {
33176 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33177 }
33178 {
33179 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33180 }
33181 {
33182 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33183 }
33184 {
33185 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33186 }
33187 {
33188 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33189 }
33190 {
33191 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33192 }
33193 {
33194 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33204 }
33205 {
33206 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33207 }
33208 {
33209 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33210 }
33211 {
33212 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33213 }
33214 {
33215 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33216 }
33217 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33218 {
33219 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33232 }
33233
33234 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33235
33236 {
33237 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33256 }
33257 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33258 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33259 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33260 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33261 {
33262 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33266 }
33267 {
33268 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33269 }
33270 {
33271 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33272 }
33273 {
33274 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33275 }
33276 {
33277 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33278 }
33279 {
33280 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33284 }
33285 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33286 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33287 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33288 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33289 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33290 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33291 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33292 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33293 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33294 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33295 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33296 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33297 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33298 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33299 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33300 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33301 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33302 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33303 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33304 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33305 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33306 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33307 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33308 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33309 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33310 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33311 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33312 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33313 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33314 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33315 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33316 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33317 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33318 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33319 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33320 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33321 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33322 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33323 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33324 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33325 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33326 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33327 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33328 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33329 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33330
33331 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33332
33333 {
33334 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33359 }
33360 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33361 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33362 {
33363 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33826 }
33827 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33828 {
33829 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33887 }
33888 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33889 {
33890 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33924 }
33925
33926 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33927 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33928 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33929 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33930
33931 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33932 }
33933
wxWidgets (Impactor)