]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
'[1219035] cleanup: miscellaneous' and minor source cleaning.
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLogChain swig_types[0]
1343 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1344 #define SWIGTYPE_p_wxMetafile swig_types[2]
1345 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1346 #define SWIGTYPE_p_wxLog swig_types[4]
1347 #define SWIGTYPE_p_wxMenu swig_types[5]
1348 #define SWIGTYPE_p_wxEvent swig_types[6]
1349 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1350 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1351 #define SWIGTYPE_p_wxDisplay swig_types[9]
1352 #define SWIGTYPE_p_wxFileType swig_types[10]
1353 #define SWIGTYPE_p_wxLogGui swig_types[11]
1354 #define SWIGTYPE_p_wxFont swig_types[12]
1355 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1356 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1357 #define SWIGTYPE_p_wxCaret swig_types[15]
1358 #define SWIGTYPE_ptrdiff_t swig_types[16]
1359 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1360 #define SWIGTYPE_p_void swig_types[18]
1361 #define SWIGTYPE_p_int swig_types[19]
1362 #define SWIGTYPE_p_wxSize swig_types[20]
1363 #define SWIGTYPE_p_wxClipboard swig_types[21]
1364 #define SWIGTYPE_p_wxStopWatch swig_types[22]
1365 #define SWIGTYPE_p_wxDC swig_types[23]
1366 #define SWIGTYPE_p_wxClipboardLocker swig_types[24]
1367 #define SWIGTYPE_p_wxIcon swig_types[25]
1368 #define SWIGTYPE_p_wxLogStderr swig_types[26]
1369 #define SWIGTYPE_p_wxLogTextCtrl swig_types[27]
1370 #define SWIGTYPE_p_wxTextCtrl swig_types[28]
1371 #define SWIGTYPE_p_wxBusyCursor swig_types[29]
1372 #define SWIGTYPE_p_wxBitmapDataObject swig_types[30]
1373 #define SWIGTYPE_p_wxTextDataObject swig_types[31]
1374 #define SWIGTYPE_p_wxDataObject swig_types[32]
1375 #define SWIGTYPE_p_wxPyTextDataObject swig_types[33]
1376 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[34]
1377 #define SWIGTYPE_p_wxFileDataObject swig_types[35]
1378 #define SWIGTYPE_p_wxCustomDataObject swig_types[36]
1379 #define SWIGTYPE_p_wxURLDataObject swig_types[37]
1380 #define SWIGTYPE_p_wxMetafileDataObject swig_types[38]
1381 #define SWIGTYPE_p_wxSound swig_types[39]
1382 #define SWIGTYPE_p_wxTimerRunner swig_types[40]
1383 #define SWIGTYPE_p_wxLogWindow swig_types[41]
1384 #define SWIGTYPE_p_wxTimeSpan swig_types[42]
1385 #define SWIGTYPE_p_wxArrayString swig_types[43]
1386 #define SWIGTYPE_p_wxWindowDisabler swig_types[44]
1387 #define SWIGTYPE_p_form_ops_t swig_types[45]
1388 #define SWIGTYPE_p_wxToolTip swig_types[46]
1389 #define SWIGTYPE_p_wxDataObjectComposite swig_types[47]
1390 #define SWIGTYPE_p_wxSystemSettings swig_types[48]
1391 #define SWIGTYPE_p_wxFileConfig swig_types[49]
1392 #define SWIGTYPE_p_wxVideoMode swig_types[50]
1393 #define SWIGTYPE_p_wxDataObjectSimple swig_types[51]
1394 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[52]
1395 #define SWIGTYPE_p_wxDuplexMode swig_types[53]
1396 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
1397 #define SWIGTYPE_p_wxRect swig_types[55]
1398 #define SWIGTYPE_p_char swig_types[56]
1399 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[57]
1400 #define SWIGTYPE_p_wxStandardPaths swig_types[58]
1401 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
1402 #define SWIGTYPE_p_wxFrame swig_types[60]
1403 #define SWIGTYPE_p_wxTimer swig_types[61]
1404 #define SWIGTYPE_p_wxPaperSize swig_types[62]
1405 #define SWIGTYPE_p_wxMimeTypesManager swig_types[63]
1406 #define SWIGTYPE_p_wxPyArtProvider swig_types[64]
1407 #define SWIGTYPE_p_wxPyTipProvider swig_types[65]
1408 #define SWIGTYPE_p_wxTipProvider swig_types[66]
1409 #define SWIGTYPE_p_wxJoystick swig_types[67]
1410 #define SWIGTYPE_p_wxSystemOptions swig_types[68]
1411 #define SWIGTYPE_p_wxPoint swig_types[69]
1412 #define SWIGTYPE_p_wxJoystickEvent swig_types[70]
1413 #define SWIGTYPE_p_wxCursor swig_types[71]
1414 #define SWIGTYPE_p_wxObject swig_types[72]
1415 #define SWIGTYPE_p_wxOutputStream swig_types[73]
1416 #define SWIGTYPE_p_wxDateTime swig_types[74]
1417 #define SWIGTYPE_p_wxPyDropSource swig_types[75]
1418 #define SWIGTYPE_p_unsigned_long swig_types[76]
1419 #define SWIGTYPE_p_wxLogBuffer swig_types[77]
1420 #define SWIGTYPE_p_wxKillError swig_types[78]
1421 #define SWIGTYPE_p_wxWindow swig_types[79]
1422 #define SWIGTYPE_p_wxString swig_types[80]
1423 #define SWIGTYPE_p_wxPyProcess swig_types[81]
1424 #define SWIGTYPE_p_wxBitmap swig_types[82]
1425 #define SWIGTYPE_unsigned_int swig_types[83]
1426 #define SWIGTYPE_p_unsigned_int swig_types[84]
1427 #define SWIGTYPE_p_wxConfig swig_types[85]
1428 #define SWIGTYPE_p_unsigned_char swig_types[86]
1429 #define SWIGTYPE_p_wxChar swig_types[87]
1430 #define SWIGTYPE_p_wxBusyInfo swig_types[88]
1431 #define SWIGTYPE_p_wxPyDropTarget swig_types[89]
1432 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[90]
1433 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[91]
1434 #define SWIGTYPE_p_wxProcessEvent swig_types[92]
1435 #define SWIGTYPE_p_wxPyLog swig_types[93]
1436 #define SWIGTYPE_p_wxLogNull swig_types[94]
1437 #define SWIGTYPE_p_wxColour swig_types[95]
1438 #define SWIGTYPE_p_wxPyTimer swig_types[96]
1439 #define SWIGTYPE_p_wxConfigPathChanger swig_types[97]
1440 #define SWIGTYPE_p_wxDateSpan swig_types[98]
1441 static swig_type_info *swig_types[100];
1442
1443 /* -------- TYPES TABLE (END) -------- */
1444
1445
1446 /*-----------------------------------------------
1447 @(target):= _misc_.so
1448 ------------------------------------------------*/
1449 #define SWIG_init init_misc_
1450
1451 #define SWIG_name "_misc_"
1452
1453 #include "wx/wxPython/wxPython.h"
1454 #include "wx/wxPython/pyclasses.h"
1455 #include "wx/wxPython/pyistream.h"
1456
1457 static const wxString wxPyEmptyString(wxEmptyString);
1458
1459
1460
1461 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1462 #define SWIG_From_int PyInt_FromLong
1463 /*@@*/
1464
1465
1466 #include <limits.h>
1467
1468
1469 SWIGINTERN int
1470 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1471 const char *errmsg)
1472 {
1473 if (value < min_value) {
1474 if (errmsg) {
1475 PyErr_Format(PyExc_OverflowError,
1476 "value %ld is less than '%s' minimum %ld",
1477 value, errmsg, min_value);
1478 }
1479 return 0;
1480 } else if (value > max_value) {
1481 if (errmsg) {
1482 PyErr_Format(PyExc_OverflowError,
1483 "value %ld is greater than '%s' maximum %ld",
1484 value, errmsg, max_value);
1485 }
1486 return 0;
1487 }
1488 return 1;
1489 }
1490
1491
1492 SWIGINTERN int
1493 SWIG_AsVal_long(PyObject* obj, long* val)
1494 {
1495 if (PyNumber_Check(obj)) {
1496 if (val) *val = PyInt_AsLong(obj);
1497 return 1;
1498 }
1499 else {
1500 SWIG_type_error("number", obj);
1501 }
1502 return 0;
1503 }
1504
1505
1506 #if INT_MAX != LONG_MAX
1507 SWIGINTERN int
1508 SWIG_AsVal_int(PyObject *obj, int *val)
1509 {
1510 const char* errmsg = val ? "int" : (char*)0;
1511 long v;
1512 if (SWIG_AsVal_long(obj, &v)) {
1513 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1514 if (val) *val = (int)(v);
1515 return 1;
1516 } else {
1517 return 0;
1518 }
1519 } else {
1520 PyErr_Clear();
1521 }
1522 if (val) {
1523 SWIG_type_error(errmsg, obj);
1524 }
1525 return 0;
1526 }
1527 #else
1528 SWIGINTERNSHORT int
1529 SWIG_AsVal_int(PyObject *obj, int *val)
1530 {
1531 return SWIG_AsVal_long(obj,(long*)val);
1532 }
1533 #endif
1534
1535
1536 SWIGINTERNSHORT int
1537 SWIG_As_int(PyObject* obj)
1538 {
1539 int v;
1540 if (!SWIG_AsVal_int(obj, &v)) {
1541 /*
1542 this is needed to make valgrind/purify happier.
1543 */
1544 memset((void*)&v, 0, sizeof(int));
1545 }
1546 return v;
1547 }
1548
1549
1550 SWIGINTERNSHORT int
1551 SWIG_Check_int(PyObject* obj)
1552 {
1553 return SWIG_AsVal_int(obj, (int*)0);
1554 }
1555
1556 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1557
1558 #include <wx/stockitem.h>
1559
1560 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1561 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1562 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1563
1564 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1565 #define SWIG_From_long PyInt_FromLong
1566 /*@@*/
1567
1568
1569 SWIGINTERNSHORT long
1570 SWIG_As_long(PyObject* obj)
1571 {
1572 long v;
1573 if (!SWIG_AsVal_long(obj, &v)) {
1574 /*
1575 this is needed to make valgrind/purify happier.
1576 */
1577 memset((void*)&v, 0, sizeof(long));
1578 }
1579 return v;
1580 }
1581
1582
1583 SWIGINTERNSHORT int
1584 SWIG_Check_long(PyObject* obj)
1585 {
1586 return SWIG_AsVal_long(obj, (long*)0);
1587 }
1588
1589
1590 SWIGINTERN int
1591 SWIG_AsVal_bool(PyObject *obj, bool *val)
1592 {
1593 if (obj == Py_True) {
1594 if (val) *val = true;
1595 return 1;
1596 }
1597 if (obj == Py_False) {
1598 if (val) *val = false;
1599 return 1;
1600 }
1601 int res = 0;
1602 if (SWIG_AsVal_int(obj, &res)) {
1603 if (val) *val = res ? true : false;
1604 return 1;
1605 } else {
1606 PyErr_Clear();
1607 }
1608 if (val) {
1609 SWIG_type_error("bool", obj);
1610 }
1611 return 0;
1612 }
1613
1614
1615 SWIGINTERNSHORT bool
1616 SWIG_As_bool(PyObject* obj)
1617 {
1618 bool v;
1619 if (!SWIG_AsVal_bool(obj, &v)) {
1620 /*
1621 this is needed to make valgrind/purify happier.
1622 */
1623 memset((void*)&v, 0, sizeof(bool));
1624 }
1625 return v;
1626 }
1627
1628
1629 SWIGINTERNSHORT int
1630 SWIG_Check_bool(PyObject* obj)
1631 {
1632 return SWIG_AsVal_bool(obj, (bool*)0);
1633 }
1634
1635
1636 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1637 PyObject* o2;
1638 PyObject* o3;
1639
1640 if (!target) {
1641 target = o;
1642 } else if (target == Py_None) {
1643 Py_DECREF(Py_None);
1644 target = o;
1645 } else {
1646 if (!PyTuple_Check(target)) {
1647 o2 = target;
1648 target = PyTuple_New(1);
1649 PyTuple_SetItem(target, 0, o2);
1650 }
1651 o3 = PyTuple_New(1);
1652 PyTuple_SetItem(o3, 0, o);
1653
1654 o2 = target;
1655 target = PySequence_Concat(o2, o3);
1656 Py_DECREF(o2);
1657 Py_DECREF(o3);
1658 }
1659 return target;
1660 }
1661
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void* wxGetXDisplay()
1708 {
1709 #ifdef __WXGTK__
1710 return wxGetDisplay();
1711 #else
1712 return NULL;
1713 #endif
1714 }
1715
1716
1717 bool wxThread_IsMain() {
1718 #ifdef WXP_WITH_THREAD
1719 return wxThread::IsMain();
1720 #else
1721 return true;
1722 #endif
1723 }
1724
1725 static void wxCaret_Destroy(wxCaret *self){
1726 delete self;
1727 }
1728
1729 #include <wx/snglinst.h>
1730
1731
1732 #ifdef __WXMSW__
1733 #include <wx/msw/private.h>
1734 #include <wx/dynload.h>
1735 #endif
1736
1737
1738
1739 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1740 #if 0
1741 , int method
1742 #endif
1743 )
1744 {
1745 #ifdef __WXMSW__
1746 #if 0
1747 switch (method)
1748 {
1749 case 1:
1750 // This one only partially works. Appears to be an undocumented
1751 // "standard" convention that not all widgets adhear to. For
1752 // example, for some widgets backgrounds or non-client areas may
1753 // not be painted.
1754 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1755 break;
1756
1757 case 2:
1758 #endif
1759 // This one works much better, nearly all widgets and their
1760 // children are captured correctly[**]. Prior to the big
1761 // background erase changes that Vadim did in 2004-2005 this
1762 // method failed badly on XP with Themes activated, most native
1763 // widgets draw only partially, if at all. Without themes it
1764 // worked just like on Win2k. After those changes this method
1765 // works very well.
1766 //
1767 // ** For example the radio buttons in a wxRadioBox are not its
1768 // children by default, but you can capture it via the panel
1769 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1770 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1771 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1772 PRF_ERASEBKGND | PRF_OWNED );
1773 return true;
1774 #if 0
1775 break;
1776
1777 case 3:
1778 // This one is only defined in the latest SDK and is only
1779 // available on XP. MSDN says it is similar to sending WM_PRINT
1780 // so I expect that it will work similar to the above. Since it
1781 // is avaialble only on XP, it can't be compiled like this and
1782 // will have to be loaded dynamically.
1783 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1784
1785 // fall through
1786
1787 case 4:
1788 // Use PrintWindow if available, or fallback to WM_PRINT
1789 // otherwise. Unfortunately using PrintWindow is even worse than
1790 // WM_PRINT. For most native widgets nothing is drawn to the dc
1791 // at all, with or without Themes.
1792 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1793 static bool s_triedToLoad = false;
1794 static PrintWindow_t pfnPrintWindow = NULL;
1795 if ( !s_triedToLoad )
1796 {
1797
1798 s_triedToLoad = true;
1799 wxDynamicLibrary dllUser32(_T("user32.dll"));
1800 if ( dllUser32.IsLoaded() )
1801 {
1802 wxLogNull nolog; // Don't report errors here
1803 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1804 }
1805 }
1806 if (pfnPrintWindow)
1807 {
1808 //printf("Using PrintWindow\n");
1809 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1810 }
1811 else
1812 {
1813 //printf("Using WM_PRINT\n");
1814 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1815 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1816 PRF_ERASEBKGND | PRF_OWNED );
1817 }
1818 }
1819 #endif // 0
1820 #else
1821 return false;
1822 #endif // __WXMSW__
1823 }
1824
1825
1826
1827 #include <wx/tipdlg.h>
1828
1829
1830 class wxPyTipProvider : public wxTipProvider {
1831 public:
1832 wxPyTipProvider(size_t currentTip)
1833 : wxTipProvider(currentTip) {}
1834
1835 DEC_PYCALLBACK_STRING__pure(GetTip);
1836 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1837 PYPRIVATE;
1838 };
1839
1840 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1841 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1842
1843
1844 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1845
1846 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1847
1848 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1849 : wxTimer(owner, id)
1850 {
1851 if (owner == NULL) SetOwner(this);
1852 }
1853
1854
1855 void wxPyTimer::Notify() {
1856 bool found;
1857 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1858 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1859 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1860 wxPyEndBlockThreads(blocked);
1861 if (! found)
1862 wxTimer::Notify();
1863 }
1864 void wxPyTimer::base_Notify() {
1865 wxTimer::Notify();
1866 }
1867
1868
1869
1870 SWIGINTERN PyObject *
1871 SWIG_FromCharPtr(const char* cptr)
1872 {
1873 if (cptr) {
1874 size_t size = strlen(cptr);
1875 if (size > INT_MAX) {
1876 return SWIG_NewPointerObj((char*)(cptr),
1877 SWIG_TypeQuery("char *"), 0);
1878 } else {
1879 if (size != 0) {
1880 return PyString_FromStringAndSize(cptr, size);
1881 } else {
1882 return PyString_FromString(cptr);
1883 }
1884 }
1885 }
1886 Py_INCREF(Py_None);
1887 return Py_None;
1888 }
1889
1890
1891 SWIGINTERNSHORT int
1892 SWIG_CheckUnsignedLongInRange(unsigned long value,
1893 unsigned long max_value,
1894 const char *errmsg)
1895 {
1896 if (value > max_value) {
1897 if (errmsg) {
1898 PyErr_Format(PyExc_OverflowError,
1899 "value %lu is greater than '%s' minimum %lu",
1900 value, errmsg, max_value);
1901 }
1902 return 0;
1903 }
1904 return 1;
1905 }
1906
1907
1908 #if UINT_MAX != ULONG_MAX
1909 SWIGINTERN int
1910 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1911 {
1912 const char* errmsg = val ? "unsigned int" : (char*)0;
1913 unsigned long v;
1914 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1915 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1916 if (val) *val = (unsigned int)(v);
1917 return 1;
1918 }
1919 } else {
1920 PyErr_Clear();
1921 }
1922 if (val) {
1923 SWIG_type_error(errmsg, obj);
1924 }
1925 return 0;
1926 }
1927 #else
1928 SWIGINTERNSHORT unsigned int
1929 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1930 {
1931 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1932 }
1933 #endif
1934
1935
1936 SWIGINTERNSHORT unsigned int
1937 SWIG_As_unsigned_SS_int(PyObject* obj)
1938 {
1939 unsigned int v;
1940 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1941 /*
1942 this is needed to make valgrind/purify happier.
1943 */
1944 memset((void*)&v, 0, sizeof(unsigned int));
1945 }
1946 return v;
1947 }
1948
1949
1950 SWIGINTERNSHORT int
1951 SWIG_Check_unsigned_SS_int(PyObject* obj)
1952 {
1953 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1954 }
1955
1956 static wxString Log_TimeStamp(){
1957 wxString msg;
1958 wxLog::TimeStamp(&msg);
1959 return msg;
1960 }
1961 static void wxLog_Destroy(wxLog *self){ delete self; }
1962 // Make somce wrappers that double any % signs so they are 'escaped'
1963 void wxPyLogFatalError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogFatalError(m);
1968 }
1969
1970 void wxPyLogError(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogError(m);
1975 }
1976
1977 void wxPyLogWarning(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogWarning(m);
1982 }
1983
1984 void wxPyLogMessage(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogMessage(m);
1989 }
1990
1991 void wxPyLogInfo(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogInfo(m);
1996 }
1997
1998 void wxPyLogDebug(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogDebug(m);
2003 }
2004
2005 void wxPyLogVerbose(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogVerbose(m);
2010 }
2011
2012 void wxPyLogStatus(const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(m);
2017 }
2018
2019 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogStatus(pFrame, m);
2024 }
2025
2026 void wxPyLogSysError(const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogSysError(m);
2031 }
2032
2033 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogGeneric(level, m);
2038 }
2039
2040 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2048 {
2049 wxString m(msg);
2050 m.Replace(wxT("%"), wxT("%%"));
2051 wxLogTrace(mask, m);
2052 }
2053
2054
2055
2056 // A wxLog class that can be derived from in wxPython
2057 class wxPyLog : public wxLog {
2058 public:
2059 wxPyLog() : wxLog() {}
2060
2061 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2062 bool found;
2063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLog(level, szString, t);
2072 }
2073
2074 virtual void DoLogString(const wxChar *szString, time_t t) {
2075 bool found;
2076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2077 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2078 PyObject* s = wx2PyString(szString);
2079 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2080 Py_DECREF(s);
2081 }
2082 wxPyEndBlockThreads(blocked);
2083 if (! found)
2084 wxLog::DoLogString(szString, t);
2085 }
2086
2087 PYPRIVATE;
2088 };
2089
2090
2091
2092
2093 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2094
2095
2096 #include <wx/joystick.h>
2097
2098
2099 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2100 // A C++ stub class for wxJoystick for platforms that don't have it.
2101 class wxJoystick : public wxObject {
2102 public:
2103 wxJoystick(int joystick = wxJOYSTICK1) {
2104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2105 PyErr_SetString(PyExc_NotImplementedError,
2106 "wxJoystick is not available on this platform.");
2107 wxPyEndBlockThreads(blocked);
2108 }
2109 wxPoint GetPosition() { return wxPoint(-1,-1); }
2110 int GetZPosition() { return -1; }
2111 int GetButtonState() { return -1; }
2112 int GetPOVPosition() { return -1; }
2113 int GetPOVCTSPosition() { return -1; }
2114 int GetRudderPosition() { return -1; }
2115 int GetUPosition() { return -1; }
2116 int GetVPosition() { return -1; }
2117 int GetMovementThreshold() { return -1; }
2118 void SetMovementThreshold(int threshold) {}
2119
2120 bool IsOk(void) { return false; }
2121 int GetNumberJoysticks() { return -1; }
2122 int GetManufacturerId() { return -1; }
2123 int GetProductId() { return -1; }
2124 wxString GetProductName() { return wxEmptyString; }
2125 int GetXMin() { return -1; }
2126 int GetYMin() { return -1; }
2127 int GetZMin() { return -1; }
2128 int GetXMax() { return -1; }
2129 int GetYMax() { return -1; }
2130 int GetZMax() { return -1; }
2131 int GetNumberButtons() { return -1; }
2132 int GetNumberAxes() { return -1; }
2133 int GetMaxButtons() { return -1; }
2134 int GetMaxAxes() { return -1; }
2135 int GetPollingMin() { return -1; }
2136 int GetPollingMax() { return -1; }
2137 int GetRudderMin() { return -1; }
2138 int GetRudderMax() { return -1; }
2139 int GetUMin() { return -1; }
2140 int GetUMax() { return -1; }
2141 int GetVMin() { return -1; }
2142 int GetVMax() { return -1; }
2143
2144 bool HasRudder() { return false; }
2145 bool HasZ() { return false; }
2146 bool HasU() { return false; }
2147 bool HasV() { return false; }
2148 bool HasPOV() { return false; }
2149 bool HasPOV4Dir() { return false; }
2150 bool HasPOVCTS() { return false; }
2151
2152 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2153 bool ReleaseCapture() { return false; }
2154 };
2155 #endif
2156
2157
2158 #include <wx/sound.h>
2159
2160
2161 #if !wxUSE_SOUND
2162 // A C++ stub class for wxWave for platforms that don't have it.
2163 class wxSound : public wxObject
2164 {
2165 public:
2166 wxSound() {
2167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2168 PyErr_SetString(PyExc_NotImplementedError,
2169 "wxSound is not available on this platform.");
2170 wxPyEndBlockThreads(blocked);
2171 }
2172 wxSound(const wxString&/*, bool*/) {
2173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2174 PyErr_SetString(PyExc_NotImplementedError,
2175 "wxSound is not available on this platform.");
2176 wxPyEndBlockThreads(blocked);
2177 }
2178 wxSound(int, const wxByte*) {
2179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2180 PyErr_SetString(PyExc_NotImplementedError,
2181 "wxSound is not available on this platform.");
2182 wxPyEndBlockThreads(blocked);
2183 }
2184
2185 ~wxSound() {};
2186
2187 bool Create(const wxString&/*, bool*/) { return false; }
2188 bool Create(int, const wxByte*) { return false; };
2189 bool IsOk() { return false; };
2190 bool Play(unsigned) const { return false; }
2191 static bool Play(const wxString&, unsigned) { return false; }
2192 static void Stop() {}
2193 };
2194
2195 #endif
2196
2197 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2198 if (fileName.Length() == 0)
2199 return new wxSound;
2200 else
2201 return new wxSound(fileName);
2202 }
2203 static wxSound *new_wxSound(PyObject *data){
2204 unsigned char* buffer; int size;
2205 wxSound *sound = NULL;
2206
2207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2208 if (!PyArg_Parse(data, "t#", &buffer, &size))
2209 goto done;
2210 sound = new wxSound(size, buffer);
2211 done:
2212 wxPyEndBlockThreads(blocked);
2213 return sound;
2214 }
2215 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2216 #ifndef __WXMAC__
2217 unsigned char* buffer;
2218 int size;
2219 bool rv = false;
2220
2221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2222 if (!PyArg_Parse(data, "t#", &buffer, &size))
2223 goto done;
2224 rv = self->Create(size, buffer);
2225 done:
2226 wxPyEndBlockThreads(blocked);
2227 return rv;
2228 #else
2229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2230 PyErr_SetString(PyExc_NotImplementedError,
2231 "Create from data is not available on this platform.");
2232 wxPyEndBlockThreads(blocked);
2233 return false;
2234 #endif
2235 }
2236
2237 #include <wx/mimetype.h>
2238
2239 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2240 wxString str;
2241 if (self->GetMimeType(&str))
2242 return wx2PyString(str);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetMimeTypes(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2254 wxArrayString arr;
2255 if (self->GetExtensions(arr))
2256 return wxArrayString2PyList_helper(arr);
2257 else
2258 RETURN_NONE();
2259 }
2260 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc))
2263 return new wxIcon(loc);
2264 else
2265 return NULL;
2266 }
2267 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2268 wxIconLocation loc;
2269 if (self->GetIcon(&loc)) {
2270 wxString iconFile = loc.GetFileName();
2271 int iconIndex = -1;
2272
2273
2274
2275 // Make a tuple and put the values in it
2276 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2277 PyObject* tuple = PyTuple_New(3);
2278 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2279 wxT("wxIcon"), true));
2280 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2281 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2282 wxPyEndBlockThreads(blocked);
2283 return tuple;
2284 }
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetDescription(wxFileType *self){
2289 wxString str;
2290 if (self->GetDescription(&str))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxString str;
2304 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2305 return wx2PyString(str);
2306 else
2307 RETURN_NONE();
2308 }
2309 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2310 wxArrayString verbs;
2311 wxArrayString commands;
2312 if (self->GetAllCommands(&verbs, &commands,
2313 wxFileType::MessageParameters(filename, mimetype))) {
2314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2315 PyObject* tuple = PyTuple_New(2);
2316 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2317 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2318 wxPyEndBlockThreads(blocked);
2319 return tuple;
2320 }
2321 else
2322 RETURN_NONE();
2323 }
2324 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2325 return wxFileType::ExpandCommand(command,
2326 wxFileType::MessageParameters(filename, mimetype));
2327 }
2328 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2329 wxArrayString arr;
2330 self->EnumAllFileTypes(arr);
2331 return wxArrayString2PyList_helper(arr);
2332 }
2333
2334 #include <wx/artprov.h>
2335
2336 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2337 static const wxString wxPyART_MENU(wxART_MENU);
2338 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2339 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2340 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2341 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2342 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2343 static const wxString wxPyART_OTHER(wxART_OTHER);
2344 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2345 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2346 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2347 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2348 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2349 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2350 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2351 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2352 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2353 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2354 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2355 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2356 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2357 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2358 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2359 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2360 static const wxString wxPyART_PRINT(wxART_PRINT);
2361 static const wxString wxPyART_HELP(wxART_HELP);
2362 static const wxString wxPyART_TIP(wxART_TIP);
2363 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2364 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2365 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2366 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2367 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2368 static const wxString wxPyART_CDROM(wxART_CDROM);
2369 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2370 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2371 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2372 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2373 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2374 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2375 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2376 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2377 static const wxString wxPyART_ERROR(wxART_ERROR);
2378 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2379 static const wxString wxPyART_WARNING(wxART_WARNING);
2380 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2381 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2382 static const wxString wxPyART_COPY(wxART_COPY);
2383 static const wxString wxPyART_CUT(wxART_CUT);
2384 static const wxString wxPyART_PASTE(wxART_PASTE);
2385 static const wxString wxPyART_DELETE(wxART_DELETE);
2386 static const wxString wxPyART_NEW(wxART_NEW);
2387 static const wxString wxPyART_UNDO(wxART_UNDO);
2388 static const wxString wxPyART_REDO(wxART_REDO);
2389 static const wxString wxPyART_QUIT(wxART_QUIT);
2390 static const wxString wxPyART_FIND(wxART_FIND);
2391 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2392 // Python aware wxArtProvider
2393 class wxPyArtProvider : public wxArtProvider {
2394 public:
2395
2396 virtual wxBitmap CreateBitmap(const wxArtID& id,
2397 const wxArtClient& client,
2398 const wxSize& size) {
2399 wxBitmap rval = wxNullBitmap;
2400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2401 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2402 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2403 PyObject* ro;
2404 wxBitmap* ptr;
2405 PyObject* s1, *s2;
2406 s1 = wx2PyString(id);
2407 s2 = wx2PyString(client);
2408 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2409 Py_DECREF(so);
2410 Py_DECREF(s1);
2411 Py_DECREF(s2);
2412 if (ro) {
2413 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2414 rval = *ptr;
2415 Py_DECREF(ro);
2416 }
2417 }
2418 wxPyEndBlockThreads(blocked);
2419 return rval;
2420 }
2421
2422 PYPRIVATE;
2423 };
2424
2425 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2426
2427
2428
2429 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2430 PyObject* ret = PyTuple_New(3);
2431 if (ret) {
2432 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2433 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2434 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2435 }
2436 return ret;
2437 }
2438
2439 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2440 bool cont;
2441 long index = 0;
2442 wxString value;
2443
2444 cont = self->GetFirstGroup(value, index);
2445 return __EnumerationHelper(cont, value, index);
2446 }
2447 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2448 bool cont;
2449 wxString value;
2450
2451 cont = self->GetNextGroup(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2455 bool cont;
2456 long index = 0;
2457 wxString value;
2458
2459 cont = self->GetFirstEntry(value, index);
2460 return __EnumerationHelper(cont, value, index);
2461 }
2462 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2463 bool cont;
2464 wxString value;
2465
2466 cont = self->GetNextEntry(value, index);
2467 return __EnumerationHelper(cont, value, index);
2468 }
2469 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2470 long rv;
2471 self->Read(key, &rv, defaultVal);
2472 return rv;
2473 }
2474
2475 SWIGINTERN int
2476 SWIG_AsVal_double(PyObject *obj, double* val)
2477 {
2478 if (PyNumber_Check(obj)) {
2479 if (val) *val = PyFloat_AsDouble(obj);
2480 return 1;
2481 }
2482 else {
2483 SWIG_type_error("number", obj);
2484 }
2485 return 0;
2486 }
2487
2488
2489 SWIGINTERNSHORT double
2490 SWIG_As_double(PyObject* obj)
2491 {
2492 double v;
2493 if (!SWIG_AsVal_double(obj, &v)) {
2494 /*
2495 this is needed to make valgrind/purify happier.
2496 */
2497 memset((void*)&v, 0, sizeof(double));
2498 }
2499 return v;
2500 }
2501
2502
2503 SWIGINTERNSHORT int
2504 SWIG_Check_double(PyObject* obj)
2505 {
2506 return SWIG_AsVal_double(obj, (double*)0);
2507 }
2508
2509 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2510 double rv;
2511 self->Read(key, &rv, defaultVal);
2512 return rv;
2513 }
2514
2515 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2516 #define SWIG_From_double PyFloat_FromDouble
2517 /*@@*/
2518
2519 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2520 bool rv;
2521 self->Read(key, &rv, defaultVal);
2522 return rv;
2523 }
2524
2525 #include <wx/datetime.h>
2526
2527 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2528 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2529
2530 #define LOCAL_TZ wxDateTime::Local
2531
2532 static PyObject *DateTime_GetAmPmStrings(){
2533 wxString am;
2534 wxString pm;
2535 wxDateTime::GetAmPmStrings(&am, &pm);
2536 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2537 PyObject* tup = PyTuple_New(2);
2538 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2539 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2540 wxPyEndBlockThreads(blocked);
2541 return tup;
2542 }
2543
2544 #if UINT_MAX < LONG_MAX
2545 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2546 #define SWIG_From_unsigned_SS_int SWIG_From_long
2547 /*@@*/
2548 #else
2549 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2550 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2551 /*@@*/
2552 #endif
2553
2554 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2555 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2556 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2557 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2558 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2559 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2560 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2561 return (*self < *other);
2562 }
2563 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2565 return (*self <= *other);
2566 }
2567 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2569 return (*self > *other);
2570 }
2571 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2573 return (*self >= *other);
2574 }
2575 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2576 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2577 return (*self == *other);
2578 }
2579 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2580 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2581 return (*self != *other);
2582 }
2583 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2584 const wxChar* rv;
2585 const wxChar* _date = date;
2586 rv = self->ParseRfc822Date(_date);
2587 if (rv == NULL) return -1;
2588 return rv - _date;
2589 }
2590 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseFormat(_date, format, dateDef);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2598 const wxChar* rv;
2599 const wxChar* _datetime = datetime;
2600 rv = self->ParseDateTime(_datetime);
2601 if (rv == NULL) return -1;
2602 return rv - _datetime;
2603 }
2604 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2605 const wxChar* rv;
2606 const wxChar* _date = date;
2607 rv = self->ParseDate(_date);
2608 if (rv == NULL) return -1;
2609 return rv - _date;
2610 }
2611 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2612 const wxChar* rv;
2613 const wxChar* _time = time;
2614 rv = self->ParseTime(_time);
2615 if (rv == NULL) return -1;
2616 return rv - _time;
2617 }
2618 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2619 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2620 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2621 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2622 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2623 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2624 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2625 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2626 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2627 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2628 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2629 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2630 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2631 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2632 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2633 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2634
2635 #include <wx/dataobj.h>
2636
2637 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2638 size_t count = self->GetFormatCount(dir);
2639 wxDataFormat* formats = new wxDataFormat[count];
2640 self->GetAllFormats(formats, dir);
2641
2642 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2643 PyObject* list = PyList_New(count);
2644 for (size_t i=0; i<count; i++) {
2645 wxDataFormat* format = new wxDataFormat(formats[i]);
2646 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2647 PyList_Append(list, obj);
2648 Py_DECREF(obj);
2649 }
2650 wxPyEndBlockThreads(blocked);
2651 delete [] formats;
2652 return list;
2653 }
2654 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2655 PyObject* rval = NULL;
2656 size_t size = self->GetDataSize(format);
2657 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2658 if (size) {
2659 char* buf = new char[size];
2660 if (self->GetDataHere(format, buf))
2661 rval = PyString_FromStringAndSize(buf, size);
2662 delete [] buf;
2663 }
2664 if (! rval) {
2665 rval = Py_None;
2666 Py_INCREF(rval);
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2672 bool rval;
2673 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2674 if (PyString_Check(data)) {
2675 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2676 }
2677 else {
2678 // raise a TypeError if not a string
2679 PyErr_SetString(PyExc_TypeError, "String expected.");
2680 rval = false;
2681 }
2682 wxPyEndBlockThreads(blocked);
2683 return rval;
2684 }
2685 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2686 PyObject* rval = NULL;
2687 size_t size = self->GetDataSize();
2688 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2689 if (size) {
2690 char* buf = new char[size];
2691 if (self->GetDataHere(buf))
2692 rval = PyString_FromStringAndSize(buf, size);
2693 delete [] buf;
2694 }
2695 if (! rval) {
2696 rval = Py_None;
2697 Py_INCREF(rval);
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2703 bool rval;
2704 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2705 if (PyString_Check(data)) {
2706 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2707 }
2708 else {
2709 // raise a TypeError if not a string
2710 PyErr_SetString(PyExc_TypeError, "String expected.");
2711 rval = false;
2712 }
2713 wxPyEndBlockThreads(blocked);
2714 return rval;
2715 }
2716 // Create a new class for wxPython to use
2717 class wxPyDataObjectSimple : public wxDataObjectSimple {
2718 public:
2719 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2720 : wxDataObjectSimple(format) {}
2721
2722 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2723 bool GetDataHere(void *buf) const;
2724 bool SetData(size_t len, const void *buf) const;
2725 PYPRIVATE;
2726 };
2727
2728 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2729
2730 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2731 // We need to get the data for this object and write it to buf. I think
2732 // the best way to do this for wxPython is to have the Python method
2733 // return either a string or None and then act appropriately with the
2734 // C++ version.
2735
2736 bool rval = false;
2737 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2738 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2739 PyObject* ro;
2740 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2741 if (ro) {
2742 rval = (ro != Py_None && PyString_Check(ro));
2743 if (rval)
2744 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2745 Py_DECREF(ro);
2746 }
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2753 // For this one we simply need to make a string from buf and len
2754 // and send it to the Python method.
2755 bool rval = false;
2756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2757 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2758 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2759 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2760 Py_DECREF(data);
2761 }
2762 wxPyEndBlockThreads(blocked);
2763 return rval;
2764 }
2765
2766 // Create a new class for wxPython to use
2767 class wxPyTextDataObject : public wxTextDataObject {
2768 public:
2769 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2770 : wxTextDataObject(text) {}
2771
2772 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2773 DEC_PYCALLBACK_STRING__const(GetText);
2774 DEC_PYCALLBACK__STRING(SetText);
2775 PYPRIVATE;
2776 };
2777
2778 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2779 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2780 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2781
2782
2783 // Create a new class for wxPython to use
2784 class wxPyBitmapDataObject : public wxBitmapDataObject {
2785 public:
2786 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2787 : wxBitmapDataObject(bitmap) {}
2788
2789 wxBitmap GetBitmap() const;
2790 void SetBitmap(const wxBitmap& bitmap);
2791 PYPRIVATE;
2792 };
2793
2794 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2795 wxBitmap* rval = &wxNullBitmap;
2796 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2797 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2798 PyObject* ro;
2799 wxBitmap* ptr;
2800 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2801 if (ro) {
2802 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2803 rval = ptr;
2804 Py_DECREF(ro);
2805 }
2806 }
2807 wxPyEndBlockThreads(blocked);
2808 return *rval;
2809 }
2810
2811 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2813 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2814 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2815 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2816 Py_DECREF(bo);
2817 }
2818 wxPyEndBlockThreads(blocked);
2819 }
2820
2821 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2822 return new wxCustomDataObject(wxDataFormat(formatName));
2823 }
2824 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2825 bool rval;
2826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2827 if (PyString_Check(data)) {
2828 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2829 }
2830 else {
2831 // raise a TypeError if not a string
2832 PyErr_SetString(PyExc_TypeError, "String expected.");
2833 rval = false;
2834 }
2835 wxPyEndBlockThreads(blocked);
2836 return rval;
2837 }
2838 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2839 PyObject* obj;
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2841 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2842 wxPyEndBlockThreads(blocked);
2843 return obj;
2844 }
2845
2846 #include <wx/metafile.h>
2847
2848
2849 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2850
2851
2852 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2853 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2854 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2855 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2856 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2857
2858
2859 class wxPyTextDropTarget : public wxTextDropTarget {
2860 public:
2861 wxPyTextDropTarget() {}
2862
2863 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2864
2865 DEC_PYCALLBACK__(OnLeave);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2868 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2869 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2870
2871 PYPRIVATE;
2872 };
2873
2874 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2875 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2876 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2877 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2878 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2879 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2880
2881
2882
2883 class wxPyFileDropTarget : public wxFileDropTarget {
2884 public:
2885 wxPyFileDropTarget() {}
2886
2887 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2888
2889 DEC_PYCALLBACK__(OnLeave);
2890 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2891 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2892 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2893 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2894
2895 PYPRIVATE;
2896 };
2897
2898 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2899 const wxArrayString& filenames) {
2900 bool rval = false;
2901 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2902 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2903 PyObject* list = wxArrayString2PyList_helper(filenames);
2904 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2905 Py_DECREF(list);
2906 }
2907 wxPyEndBlockThreads(blocked);
2908 return rval;
2909 }
2910
2911
2912
2913 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2914 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2915 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2916 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2917 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2918
2919
2920
2921
2922 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2923
2924 #include <wx/display.h>
2925
2926 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2927 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2928
2929 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2930 #if !wxUSE_DISPLAY
2931 #include <wx/dynarray.h>
2932 #include <wx/vidmode.h>
2933
2934 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2935 #include "wx/arrimpl.cpp"
2936 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2937 const wxVideoMode wxDefaultVideoMode;
2938
2939 class wxDisplay
2940 {
2941 public:
2942 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2943 ~wxDisplay() {}
2944
2945 static size_t GetCount()
2946 { wxPyRaiseNotImplemented(); return 0; }
2947
2948 static int GetFromPoint(const wxPoint& pt)
2949 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2950 static int GetFromWindow(wxWindow *window)
2951 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2952
2953 virtual bool IsOk() const { return false; }
2954 virtual wxRect GetGeometry() const { wxRect r; return r; }
2955 virtual wxString GetName() const { return wxEmptyString; }
2956 bool IsPrimary() const { return false; }
2957
2958 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2959 { wxArrayVideoModes a; return a; }
2960
2961 virtual wxVideoMode GetCurrentMode() const
2962 { return wxDefaultVideoMode; }
2963
2964 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2965 { return false; }
2966
2967 void ResetMode() {}
2968 };
2969 #endif
2970
2971 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2972 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2973 PyObject* pyList = NULL;
2974 wxArrayVideoModes arr = self->GetModes(mode);
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 pyList = PyList_New(0);
2977 for (int i=0; i < arr.GetCount(); i++) {
2978 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2979 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2980 PyList_Append(pyList, pyObj);
2981 Py_DECREF(pyObj);
2982 }
2983 wxPyEndBlockThreads(blocked);
2984 return pyList;
2985 }
2986
2987 #include <wx/stdpaths.h>
2988
2989 static wxStandardPaths *StandardPaths_Get(){
2990 return (wxStandardPaths*) &wxStandardPaths::Get();
2991 }
2992 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2993 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2994 #ifdef __cplusplus
2995 extern "C" {
2996 #endif
2997 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2998 PyObject *resultobj;
2999 wxSystemColour arg1 ;
3000 wxColour result;
3001 PyObject * obj0 = 0 ;
3002 char *kwnames[] = {
3003 (char *) "index", NULL
3004 };
3005
3006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3007 {
3008 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3009 if (SWIG_arg_fail(1)) SWIG_fail;
3010 }
3011 {
3012 if (!wxPyCheckForApp()) SWIG_fail;
3013 PyThreadState* __tstate = wxPyBeginAllowThreads();
3014 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3015
3016 wxPyEndAllowThreads(__tstate);
3017 if (PyErr_Occurred()) SWIG_fail;
3018 }
3019 {
3020 wxColour * resultptr;
3021 resultptr = new wxColour((wxColour &)(result));
3022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3023 }
3024 return resultobj;
3025 fail:
3026 return NULL;
3027 }
3028
3029
3030 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3031 PyObject *resultobj;
3032 wxSystemFont arg1 ;
3033 wxFont result;
3034 PyObject * obj0 = 0 ;
3035 char *kwnames[] = {
3036 (char *) "index", NULL
3037 };
3038
3039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3040 {
3041 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3042 if (SWIG_arg_fail(1)) SWIG_fail;
3043 }
3044 {
3045 if (!wxPyCheckForApp()) SWIG_fail;
3046 PyThreadState* __tstate = wxPyBeginAllowThreads();
3047 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3048
3049 wxPyEndAllowThreads(__tstate);
3050 if (PyErr_Occurred()) SWIG_fail;
3051 }
3052 {
3053 wxFont * resultptr;
3054 resultptr = new wxFont((wxFont &)(result));
3055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3056 }
3057 return resultobj;
3058 fail:
3059 return NULL;
3060 }
3061
3062
3063 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3064 PyObject *resultobj;
3065 wxSystemMetric arg1 ;
3066 wxWindow *arg2 = (wxWindow *) NULL ;
3067 int result;
3068 PyObject * obj0 = 0 ;
3069 PyObject * obj1 = 0 ;
3070 char *kwnames[] = {
3071 (char *) "index",(char *) "win", NULL
3072 };
3073
3074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3075 {
3076 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3077 if (SWIG_arg_fail(1)) SWIG_fail;
3078 }
3079 if (obj1) {
3080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3081 if (SWIG_arg_fail(2)) SWIG_fail;
3082 }
3083 {
3084 if (!wxPyCheckForApp()) SWIG_fail;
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1,arg2);
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 {
3092 resultobj = SWIG_From_int((int)(result));
3093 }
3094 return resultobj;
3095 fail:
3096 return NULL;
3097 }
3098
3099
3100 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3101 PyObject *resultobj;
3102 wxSystemFeature arg1 ;
3103 bool result;
3104 PyObject * obj0 = 0 ;
3105 char *kwnames[] = {
3106 (char *) "index", NULL
3107 };
3108
3109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3110 {
3111 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3112 if (SWIG_arg_fail(1)) SWIG_fail;
3113 }
3114 {
3115 if (!wxPyCheckForApp()) SWIG_fail;
3116 PyThreadState* __tstate = wxPyBeginAllowThreads();
3117 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3118
3119 wxPyEndAllowThreads(__tstate);
3120 if (PyErr_Occurred()) SWIG_fail;
3121 }
3122 {
3123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3124 }
3125 return resultobj;
3126 fail:
3127 return NULL;
3128 }
3129
3130
3131 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3132 PyObject *resultobj;
3133 wxSystemScreenType result;
3134 char *kwnames[] = {
3135 NULL
3136 };
3137
3138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3139 {
3140 if (!wxPyCheckForApp()) SWIG_fail;
3141 PyThreadState* __tstate = wxPyBeginAllowThreads();
3142 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3143
3144 wxPyEndAllowThreads(__tstate);
3145 if (PyErr_Occurred()) SWIG_fail;
3146 }
3147 resultobj = SWIG_From_int((result));
3148 return resultobj;
3149 fail:
3150 return NULL;
3151 }
3152
3153
3154 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3155 PyObject *resultobj;
3156 wxSystemScreenType arg1 ;
3157 PyObject * obj0 = 0 ;
3158 char *kwnames[] = {
3159 (char *) "screen", NULL
3160 };
3161
3162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3163 {
3164 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3165 if (SWIG_arg_fail(1)) SWIG_fail;
3166 }
3167 {
3168 if (!wxPyCheckForApp()) SWIG_fail;
3169 PyThreadState* __tstate = wxPyBeginAllowThreads();
3170 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3171
3172 wxPyEndAllowThreads(__tstate);
3173 if (PyErr_Occurred()) SWIG_fail;
3174 }
3175 Py_INCREF(Py_None); resultobj = Py_None;
3176 return resultobj;
3177 fail:
3178 return NULL;
3179 }
3180
3181
3182 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3183 PyObject *obj;
3184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3185 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3186 Py_INCREF(obj);
3187 return Py_BuildValue((char *)"");
3188 }
3189 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3190 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3191 return 1;
3192 }
3193
3194
3195 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3196 PyObject *pyobj;
3197
3198 {
3199 #if wxUSE_UNICODE
3200 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3201 #else
3202 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3203 #endif
3204 }
3205 return pyobj;
3206 }
3207
3208
3209 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3210 PyObject *resultobj;
3211 wxSystemOptions *result;
3212 char *kwnames[] = {
3213 NULL
3214 };
3215
3216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3217 {
3218 PyThreadState* __tstate = wxPyBeginAllowThreads();
3219 result = (wxSystemOptions *)new wxSystemOptions();
3220
3221 wxPyEndAllowThreads(__tstate);
3222 if (PyErr_Occurred()) SWIG_fail;
3223 }
3224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3225 return resultobj;
3226 fail:
3227 return NULL;
3228 }
3229
3230
3231 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3232 PyObject *resultobj;
3233 wxString *arg1 = 0 ;
3234 wxString *arg2 = 0 ;
3235 bool temp1 = false ;
3236 bool temp2 = false ;
3237 PyObject * obj0 = 0 ;
3238 PyObject * obj1 = 0 ;
3239 char *kwnames[] = {
3240 (char *) "name",(char *) "value", NULL
3241 };
3242
3243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3244 {
3245 arg1 = wxString_in_helper(obj0);
3246 if (arg1 == NULL) SWIG_fail;
3247 temp1 = true;
3248 }
3249 {
3250 arg2 = wxString_in_helper(obj1);
3251 if (arg2 == NULL) SWIG_fail;
3252 temp2 = true;
3253 }
3254 {
3255 PyThreadState* __tstate = wxPyBeginAllowThreads();
3256 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3257
3258 wxPyEndAllowThreads(__tstate);
3259 if (PyErr_Occurred()) SWIG_fail;
3260 }
3261 Py_INCREF(Py_None); resultobj = Py_None;
3262 {
3263 if (temp1)
3264 delete arg1;
3265 }
3266 {
3267 if (temp2)
3268 delete arg2;
3269 }
3270 return resultobj;
3271 fail:
3272 {
3273 if (temp1)
3274 delete arg1;
3275 }
3276 {
3277 if (temp2)
3278 delete arg2;
3279 }
3280 return NULL;
3281 }
3282
3283
3284 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3285 PyObject *resultobj;
3286 wxString *arg1 = 0 ;
3287 int arg2 ;
3288 bool temp1 = false ;
3289 PyObject * obj0 = 0 ;
3290 PyObject * obj1 = 0 ;
3291 char *kwnames[] = {
3292 (char *) "name",(char *) "value", NULL
3293 };
3294
3295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3296 {
3297 arg1 = wxString_in_helper(obj0);
3298 if (arg1 == NULL) SWIG_fail;
3299 temp1 = true;
3300 }
3301 {
3302 arg2 = (int)(SWIG_As_int(obj1));
3303 if (SWIG_arg_fail(2)) SWIG_fail;
3304 }
3305 {
3306 PyThreadState* __tstate = wxPyBeginAllowThreads();
3307 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3308
3309 wxPyEndAllowThreads(__tstate);
3310 if (PyErr_Occurred()) SWIG_fail;
3311 }
3312 Py_INCREF(Py_None); resultobj = Py_None;
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return resultobj;
3318 fail:
3319 {
3320 if (temp1)
3321 delete arg1;
3322 }
3323 return NULL;
3324 }
3325
3326
3327 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3328 PyObject *resultobj;
3329 wxString *arg1 = 0 ;
3330 wxString result;
3331 bool temp1 = false ;
3332 PyObject * obj0 = 0 ;
3333 char *kwnames[] = {
3334 (char *) "name", NULL
3335 };
3336
3337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3338 {
3339 arg1 = wxString_in_helper(obj0);
3340 if (arg1 == NULL) SWIG_fail;
3341 temp1 = true;
3342 }
3343 {
3344 PyThreadState* __tstate = wxPyBeginAllowThreads();
3345 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3346
3347 wxPyEndAllowThreads(__tstate);
3348 if (PyErr_Occurred()) SWIG_fail;
3349 }
3350 {
3351 #if wxUSE_UNICODE
3352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3353 #else
3354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3355 #endif
3356 }
3357 {
3358 if (temp1)
3359 delete arg1;
3360 }
3361 return resultobj;
3362 fail:
3363 {
3364 if (temp1)
3365 delete arg1;
3366 }
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxString *arg1 = 0 ;
3374 int result;
3375 bool temp1 = false ;
3376 PyObject * obj0 = 0 ;
3377 char *kwnames[] = {
3378 (char *) "name", NULL
3379 };
3380
3381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3382 {
3383 arg1 = wxString_in_helper(obj0);
3384 if (arg1 == NULL) SWIG_fail;
3385 temp1 = true;
3386 }
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3390
3391 wxPyEndAllowThreads(__tstate);
3392 if (PyErr_Occurred()) SWIG_fail;
3393 }
3394 {
3395 resultobj = SWIG_From_int((int)(result));
3396 }
3397 {
3398 if (temp1)
3399 delete arg1;
3400 }
3401 return resultobj;
3402 fail:
3403 {
3404 if (temp1)
3405 delete arg1;
3406 }
3407 return NULL;
3408 }
3409
3410
3411 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3412 PyObject *resultobj;
3413 wxString *arg1 = 0 ;
3414 bool result;
3415 bool temp1 = false ;
3416 PyObject * obj0 = 0 ;
3417 char *kwnames[] = {
3418 (char *) "name", NULL
3419 };
3420
3421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3422 {
3423 arg1 = wxString_in_helper(obj0);
3424 if (arg1 == NULL) SWIG_fail;
3425 temp1 = true;
3426 }
3427 {
3428 PyThreadState* __tstate = wxPyBeginAllowThreads();
3429 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3430
3431 wxPyEndAllowThreads(__tstate);
3432 if (PyErr_Occurred()) SWIG_fail;
3433 }
3434 {
3435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3436 }
3437 {
3438 if (temp1)
3439 delete arg1;
3440 }
3441 return resultobj;
3442 fail:
3443 {
3444 if (temp1)
3445 delete arg1;
3446 }
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj;
3453 wxString *arg1 = 0 ;
3454 bool result;
3455 bool temp1 = false ;
3456 PyObject * obj0 = 0 ;
3457 char *kwnames[] = {
3458 (char *) "name", NULL
3459 };
3460
3461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3462 {
3463 arg1 = wxString_in_helper(obj0);
3464 if (arg1 == NULL) SWIG_fail;
3465 temp1 = true;
3466 }
3467 {
3468 PyThreadState* __tstate = wxPyBeginAllowThreads();
3469 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3470
3471 wxPyEndAllowThreads(__tstate);
3472 if (PyErr_Occurred()) SWIG_fail;
3473 }
3474 {
3475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3476 }
3477 {
3478 if (temp1)
3479 delete arg1;
3480 }
3481 return resultobj;
3482 fail:
3483 {
3484 if (temp1)
3485 delete arg1;
3486 }
3487 return NULL;
3488 }
3489
3490
3491 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3492 PyObject *obj;
3493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3494 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3495 Py_INCREF(obj);
3496 return Py_BuildValue((char *)"");
3497 }
3498 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3499 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3500 return 1;
3501 }
3502
3503
3504 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3505 PyObject *pyobj;
3506
3507 {
3508 #if wxUSE_UNICODE
3509 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3510 #else
3511 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3512 #endif
3513 }
3514 return pyobj;
3515 }
3516
3517
3518 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3519 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3520 return 1;
3521 }
3522
3523
3524 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3525 PyObject *pyobj;
3526
3527 {
3528 #if wxUSE_UNICODE
3529 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3530 #else
3531 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3532 #endif
3533 }
3534 return pyobj;
3535 }
3536
3537
3538 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3539 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3540 return 1;
3541 }
3542
3543
3544 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3545 PyObject *pyobj;
3546
3547 {
3548 #if wxUSE_UNICODE
3549 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3550 #else
3551 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3552 #endif
3553 }
3554 return pyobj;
3555 }
3556
3557
3558 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3559 PyObject *resultobj;
3560 long result;
3561 char *kwnames[] = {
3562 NULL
3563 };
3564
3565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3566 {
3567 PyThreadState* __tstate = wxPyBeginAllowThreads();
3568 result = (long)wxNewId();
3569
3570 wxPyEndAllowThreads(__tstate);
3571 if (PyErr_Occurred()) SWIG_fail;
3572 }
3573 {
3574 resultobj = SWIG_From_long((long)(result));
3575 }
3576 return resultobj;
3577 fail:
3578 return NULL;
3579 }
3580
3581
3582 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3583 PyObject *resultobj;
3584 long arg1 ;
3585 PyObject * obj0 = 0 ;
3586 char *kwnames[] = {
3587 (char *) "id", NULL
3588 };
3589
3590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3591 {
3592 arg1 = (long)(SWIG_As_long(obj0));
3593 if (SWIG_arg_fail(1)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 wxRegisterId(arg1);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 Py_INCREF(Py_None); resultobj = Py_None;
3603 return resultobj;
3604 fail:
3605 return NULL;
3606 }
3607
3608
3609 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3610 PyObject *resultobj;
3611 long result;
3612 char *kwnames[] = {
3613 NULL
3614 };
3615
3616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3617 {
3618 PyThreadState* __tstate = wxPyBeginAllowThreads();
3619 result = (long)wxGetCurrentId();
3620
3621 wxPyEndAllowThreads(__tstate);
3622 if (PyErr_Occurred()) SWIG_fail;
3623 }
3624 {
3625 resultobj = SWIG_From_long((long)(result));
3626 }
3627 return resultobj;
3628 fail:
3629 return NULL;
3630 }
3631
3632
3633 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3634 PyObject *resultobj;
3635 int arg1 ;
3636 bool result;
3637 PyObject * obj0 = 0 ;
3638 char *kwnames[] = {
3639 (char *) "id", NULL
3640 };
3641
3642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3643 {
3644 arg1 = (int)(SWIG_As_int(obj0));
3645 if (SWIG_arg_fail(1)) SWIG_fail;
3646 }
3647 {
3648 PyThreadState* __tstate = wxPyBeginAllowThreads();
3649 result = (bool)wxIsStockID(arg1);
3650
3651 wxPyEndAllowThreads(__tstate);
3652 if (PyErr_Occurred()) SWIG_fail;
3653 }
3654 {
3655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3656 }
3657 return resultobj;
3658 fail:
3659 return NULL;
3660 }
3661
3662
3663 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3664 PyObject *resultobj;
3665 int arg1 ;
3666 wxString *arg2 = 0 ;
3667 bool result;
3668 bool temp2 = false ;
3669 PyObject * obj0 = 0 ;
3670 PyObject * obj1 = 0 ;
3671 char *kwnames[] = {
3672 (char *) "id",(char *) "label", NULL
3673 };
3674
3675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3676 {
3677 arg1 = (int)(SWIG_As_int(obj0));
3678 if (SWIG_arg_fail(1)) SWIG_fail;
3679 }
3680 {
3681 arg2 = wxString_in_helper(obj1);
3682 if (arg2 == NULL) SWIG_fail;
3683 temp2 = true;
3684 }
3685 {
3686 PyThreadState* __tstate = wxPyBeginAllowThreads();
3687 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3688
3689 wxPyEndAllowThreads(__tstate);
3690 if (PyErr_Occurred()) SWIG_fail;
3691 }
3692 {
3693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3694 }
3695 {
3696 if (temp2)
3697 delete arg2;
3698 }
3699 return resultobj;
3700 fail:
3701 {
3702 if (temp2)
3703 delete arg2;
3704 }
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 int arg1 ;
3712 bool arg2 = (bool) true ;
3713 wxString arg3 = (wxString) wxPyEmptyString ;
3714 wxString result;
3715 PyObject * obj0 = 0 ;
3716 PyObject * obj1 = 0 ;
3717 PyObject * obj2 = 0 ;
3718 char *kwnames[] = {
3719 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3720 };
3721
3722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3723 {
3724 arg1 = (int)(SWIG_As_int(obj0));
3725 if (SWIG_arg_fail(1)) SWIG_fail;
3726 }
3727 if (obj1) {
3728 {
3729 arg2 = (bool)(SWIG_As_bool(obj1));
3730 if (SWIG_arg_fail(2)) SWIG_fail;
3731 }
3732 }
3733 if (obj2) {
3734 {
3735 wxString* sptr = wxString_in_helper(obj2);
3736 if (sptr == NULL) SWIG_fail;
3737 arg3 = *sptr;
3738 delete sptr;
3739 }
3740 }
3741 {
3742 PyThreadState* __tstate = wxPyBeginAllowThreads();
3743 result = wxGetStockLabel(arg1,arg2,arg3);
3744
3745 wxPyEndAllowThreads(__tstate);
3746 if (PyErr_Occurred()) SWIG_fail;
3747 }
3748 {
3749 #if wxUSE_UNICODE
3750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3751 #else
3752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3753 #endif
3754 }
3755 return resultobj;
3756 fail:
3757 return NULL;
3758 }
3759
3760
3761 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3762 PyObject *resultobj;
3763 char *kwnames[] = {
3764 NULL
3765 };
3766
3767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3768 {
3769 if (!wxPyCheckForApp()) SWIG_fail;
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 wxBell();
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 Py_INCREF(Py_None); resultobj = Py_None;
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj;
3785 char *kwnames[] = {
3786 NULL
3787 };
3788
3789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3790 {
3791 if (!wxPyCheckForApp()) SWIG_fail;
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 wxEndBusyCursor();
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 Py_INCREF(Py_None); resultobj = Py_None;
3799 return resultobj;
3800 fail:
3801 return NULL;
3802 }
3803
3804
3805 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3806 PyObject *resultobj;
3807 bool arg1 = (bool) true ;
3808 long result;
3809 PyObject * obj0 = 0 ;
3810 char *kwnames[] = {
3811 (char *) "resetTimer", NULL
3812 };
3813
3814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3815 if (obj0) {
3816 {
3817 arg1 = (bool)(SWIG_As_bool(obj0));
3818 if (SWIG_arg_fail(1)) SWIG_fail;
3819 }
3820 }
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (long)wxGetElapsedTime(arg1);
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = SWIG_From_long((long)(result));
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj;
3839 int *arg1 = (int *) 0 ;
3840 int *arg2 = (int *) 0 ;
3841 int temp1 ;
3842 int res1 = 0 ;
3843 int temp2 ;
3844 int res2 = 0 ;
3845 char *kwnames[] = {
3846 NULL
3847 };
3848
3849 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3850 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3852 {
3853 if (!wxPyCheckForApp()) SWIG_fail;
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 wxGetMousePosition(arg1,arg2);
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 Py_INCREF(Py_None); resultobj = Py_None;
3861 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3862 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3863 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3864 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 bool result;
3874 char *kwnames[] = {
3875 NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3879 {
3880 PyThreadState* __tstate = wxPyBeginAllowThreads();
3881 result = (bool)wxIsBusy();
3882
3883 wxPyEndAllowThreads(__tstate);
3884 if (PyErr_Occurred()) SWIG_fail;
3885 }
3886 {
3887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3888 }
3889 return resultobj;
3890 fail:
3891 return NULL;
3892 }
3893
3894
3895 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3896 PyObject *resultobj;
3897 wxString result;
3898 char *kwnames[] = {
3899 NULL
3900 };
3901
3902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3903 {
3904 PyThreadState* __tstate = wxPyBeginAllowThreads();
3905 result = wxNow();
3906
3907 wxPyEndAllowThreads(__tstate);
3908 if (PyErr_Occurred()) SWIG_fail;
3909 }
3910 {
3911 #if wxUSE_UNICODE
3912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3913 #else
3914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3915 #endif
3916 }
3917 return resultobj;
3918 fail:
3919 return NULL;
3920 }
3921
3922
3923 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3924 PyObject *resultobj;
3925 wxString const &arg1_defvalue = wxPyEmptyString ;
3926 wxString *arg1 = (wxString *) &arg1_defvalue ;
3927 bool result;
3928 bool temp1 = false ;
3929 PyObject * obj0 = 0 ;
3930 char *kwnames[] = {
3931 (char *) "command", NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3935 if (obj0) {
3936 {
3937 arg1 = wxString_in_helper(obj0);
3938 if (arg1 == NULL) SWIG_fail;
3939 temp1 = true;
3940 }
3941 }
3942 {
3943 PyThreadState* __tstate = wxPyBeginAllowThreads();
3944 result = (bool)wxShell((wxString const &)*arg1);
3945
3946 wxPyEndAllowThreads(__tstate);
3947 if (PyErr_Occurred()) SWIG_fail;
3948 }
3949 {
3950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3951 }
3952 {
3953 if (temp1)
3954 delete arg1;
3955 }
3956 return resultobj;
3957 fail:
3958 {
3959 if (temp1)
3960 delete arg1;
3961 }
3962 return NULL;
3963 }
3964
3965
3966 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3967 PyObject *resultobj;
3968 char *kwnames[] = {
3969 NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3973 {
3974 PyThreadState* __tstate = wxPyBeginAllowThreads();
3975 wxStartTimer();
3976
3977 wxPyEndAllowThreads(__tstate);
3978 if (PyErr_Occurred()) SWIG_fail;
3979 }
3980 Py_INCREF(Py_None); resultobj = Py_None;
3981 return resultobj;
3982 fail:
3983 return NULL;
3984 }
3985
3986
3987 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj;
3989 int *arg1 = (int *) 0 ;
3990 int *arg2 = (int *) 0 ;
3991 int result;
3992 int temp1 ;
3993 int res1 = 0 ;
3994 int temp2 ;
3995 int res2 = 0 ;
3996 char *kwnames[] = {
3997 NULL
3998 };
3999
4000 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4001 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4003 {
4004 PyThreadState* __tstate = wxPyBeginAllowThreads();
4005 result = (int)wxGetOsVersion(arg1,arg2);
4006
4007 wxPyEndAllowThreads(__tstate);
4008 if (PyErr_Occurred()) SWIG_fail;
4009 }
4010 {
4011 resultobj = SWIG_From_int((int)(result));
4012 }
4013 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4014 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4015 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4016 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 wxString result;
4026 char *kwnames[] = {
4027 NULL
4028 };
4029
4030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4031 {
4032 PyThreadState* __tstate = wxPyBeginAllowThreads();
4033 result = wxGetOsDescription();
4034
4035 wxPyEndAllowThreads(__tstate);
4036 if (PyErr_Occurred()) SWIG_fail;
4037 }
4038 {
4039 #if wxUSE_UNICODE
4040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4041 #else
4042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4043 #endif
4044 }
4045 return resultobj;
4046 fail:
4047 return NULL;
4048 }
4049
4050
4051 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4052 PyObject *resultobj;
4053 long result;
4054 char *kwnames[] = {
4055 NULL
4056 };
4057
4058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 result = (long)wxGetFreeMemory();
4062
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 {
4067 resultobj = SWIG_From_long((long)(result));
4068 }
4069 return resultobj;
4070 fail:
4071 return NULL;
4072 }
4073
4074
4075 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4076 PyObject *resultobj;
4077 wxShutdownFlags arg1 ;
4078 bool result;
4079 PyObject * obj0 = 0 ;
4080 char *kwnames[] = {
4081 (char *) "wFlags", NULL
4082 };
4083
4084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4085 {
4086 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4087 if (SWIG_arg_fail(1)) SWIG_fail;
4088 }
4089 {
4090 if (!wxPyCheckForApp()) SWIG_fail;
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4093
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 {
4098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4099 }
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 int arg1 ;
4109 PyObject * obj0 = 0 ;
4110 char *kwnames[] = {
4111 (char *) "secs", NULL
4112 };
4113
4114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4115 {
4116 arg1 = (int)(SWIG_As_int(obj0));
4117 if (SWIG_arg_fail(1)) SWIG_fail;
4118 }
4119 {
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 wxSleep(arg1);
4122
4123 wxPyEndAllowThreads(__tstate);
4124 if (PyErr_Occurred()) SWIG_fail;
4125 }
4126 Py_INCREF(Py_None); resultobj = Py_None;
4127 return resultobj;
4128 fail:
4129 return NULL;
4130 }
4131
4132
4133 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4134 PyObject *resultobj;
4135 unsigned long arg1 ;
4136 PyObject * obj0 = 0 ;
4137 char *kwnames[] = {
4138 (char *) "milliseconds", NULL
4139 };
4140
4141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4142 {
4143 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4144 if (SWIG_arg_fail(1)) SWIG_fail;
4145 }
4146 {
4147 PyThreadState* __tstate = wxPyBeginAllowThreads();
4148 wxMilliSleep(arg1);
4149
4150 wxPyEndAllowThreads(__tstate);
4151 if (PyErr_Occurred()) SWIG_fail;
4152 }
4153 Py_INCREF(Py_None); resultobj = Py_None;
4154 return resultobj;
4155 fail:
4156 return NULL;
4157 }
4158
4159
4160 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4161 PyObject *resultobj;
4162 unsigned long arg1 ;
4163 PyObject * obj0 = 0 ;
4164 char *kwnames[] = {
4165 (char *) "microseconds", NULL
4166 };
4167
4168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4169 {
4170 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4171 if (SWIG_arg_fail(1)) SWIG_fail;
4172 }
4173 {
4174 PyThreadState* __tstate = wxPyBeginAllowThreads();
4175 wxMicroSleep(arg1);
4176
4177 wxPyEndAllowThreads(__tstate);
4178 if (PyErr_Occurred()) SWIG_fail;
4179 }
4180 Py_INCREF(Py_None); resultobj = Py_None;
4181 return resultobj;
4182 fail:
4183 return NULL;
4184 }
4185
4186
4187 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4188 PyObject *resultobj;
4189 bool arg1 ;
4190 PyObject * obj0 = 0 ;
4191 char *kwnames[] = {
4192 (char *) "enable", NULL
4193 };
4194
4195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4196 {
4197 arg1 = (bool)(SWIG_As_bool(obj0));
4198 if (SWIG_arg_fail(1)) SWIG_fail;
4199 }
4200 {
4201 PyThreadState* __tstate = wxPyBeginAllowThreads();
4202 wxEnableTopLevelWindows(arg1);
4203
4204 wxPyEndAllowThreads(__tstate);
4205 if (PyErr_Occurred()) SWIG_fail;
4206 }
4207 Py_INCREF(Py_None); resultobj = Py_None;
4208 return resultobj;
4209 fail:
4210 return NULL;
4211 }
4212
4213
4214 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4215 PyObject *resultobj;
4216 wxString *arg1 = 0 ;
4217 wxString result;
4218 bool temp1 = false ;
4219 PyObject * obj0 = 0 ;
4220 char *kwnames[] = {
4221 (char *) "in", NULL
4222 };
4223
4224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4225 {
4226 arg1 = wxString_in_helper(obj0);
4227 if (arg1 == NULL) SWIG_fail;
4228 temp1 = true;
4229 }
4230 {
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = wxStripMenuCodes((wxString const &)*arg1);
4233
4234 wxPyEndAllowThreads(__tstate);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 {
4238 #if wxUSE_UNICODE
4239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4240 #else
4241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4242 #endif
4243 }
4244 {
4245 if (temp1)
4246 delete arg1;
4247 }
4248 return resultobj;
4249 fail:
4250 {
4251 if (temp1)
4252 delete arg1;
4253 }
4254 return NULL;
4255 }
4256
4257
4258 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4259 PyObject *resultobj;
4260 wxString result;
4261 char *kwnames[] = {
4262 NULL
4263 };
4264
4265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4266 {
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 result = wxGetEmailAddress();
4269
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 {
4274 #if wxUSE_UNICODE
4275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4276 #else
4277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4278 #endif
4279 }
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4287 PyObject *resultobj;
4288 wxString result;
4289 char *kwnames[] = {
4290 NULL
4291 };
4292
4293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4294 {
4295 PyThreadState* __tstate = wxPyBeginAllowThreads();
4296 result = wxGetHostName();
4297
4298 wxPyEndAllowThreads(__tstate);
4299 if (PyErr_Occurred()) SWIG_fail;
4300 }
4301 {
4302 #if wxUSE_UNICODE
4303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4304 #else
4305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4306 #endif
4307 }
4308 return resultobj;
4309 fail:
4310 return NULL;
4311 }
4312
4313
4314 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4315 PyObject *resultobj;
4316 wxString result;
4317 char *kwnames[] = {
4318 NULL
4319 };
4320
4321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4322 {
4323 PyThreadState* __tstate = wxPyBeginAllowThreads();
4324 result = wxGetFullHostName();
4325
4326 wxPyEndAllowThreads(__tstate);
4327 if (PyErr_Occurred()) SWIG_fail;
4328 }
4329 {
4330 #if wxUSE_UNICODE
4331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4332 #else
4333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4334 #endif
4335 }
4336 return resultobj;
4337 fail:
4338 return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4343 PyObject *resultobj;
4344 wxString result;
4345 char *kwnames[] = {
4346 NULL
4347 };
4348
4349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 result = wxGetUserId();
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 {
4358 #if wxUSE_UNICODE
4359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4360 #else
4361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4362 #endif
4363 }
4364 return resultobj;
4365 fail:
4366 return NULL;
4367 }
4368
4369
4370 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4371 PyObject *resultobj;
4372 wxString result;
4373 char *kwnames[] = {
4374 NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4378 {
4379 PyThreadState* __tstate = wxPyBeginAllowThreads();
4380 result = wxGetUserName();
4381
4382 wxPyEndAllowThreads(__tstate);
4383 if (PyErr_Occurred()) SWIG_fail;
4384 }
4385 {
4386 #if wxUSE_UNICODE
4387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4388 #else
4389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4390 #endif
4391 }
4392 return resultobj;
4393 fail:
4394 return NULL;
4395 }
4396
4397
4398 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4399 PyObject *resultobj;
4400 wxString result;
4401 char *kwnames[] = {
4402 NULL
4403 };
4404
4405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 result = wxGetHomeDir();
4409
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 {
4414 #if wxUSE_UNICODE
4415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4416 #else
4417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4418 #endif
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4427 PyObject *resultobj;
4428 wxString const &arg1_defvalue = wxPyEmptyString ;
4429 wxString *arg1 = (wxString *) &arg1_defvalue ;
4430 wxString result;
4431 bool temp1 = false ;
4432 PyObject * obj0 = 0 ;
4433 char *kwnames[] = {
4434 (char *) "user", NULL
4435 };
4436
4437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4438 if (obj0) {
4439 {
4440 arg1 = wxString_in_helper(obj0);
4441 if (arg1 == NULL) SWIG_fail;
4442 temp1 = true;
4443 }
4444 }
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 result = wxGetUserHome((wxString const &)*arg1);
4448
4449 wxPyEndAllowThreads(__tstate);
4450 if (PyErr_Occurred()) SWIG_fail;
4451 }
4452 {
4453 #if wxUSE_UNICODE
4454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4455 #else
4456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4457 #endif
4458 }
4459 {
4460 if (temp1)
4461 delete arg1;
4462 }
4463 return resultobj;
4464 fail:
4465 {
4466 if (temp1)
4467 delete arg1;
4468 }
4469 return NULL;
4470 }
4471
4472
4473 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4474 PyObject *resultobj;
4475 unsigned long result;
4476 char *kwnames[] = {
4477 NULL
4478 };
4479
4480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4481 {
4482 PyThreadState* __tstate = wxPyBeginAllowThreads();
4483 result = (unsigned long)wxGetProcessId();
4484
4485 wxPyEndAllowThreads(__tstate);
4486 if (PyErr_Occurred()) SWIG_fail;
4487 }
4488 {
4489 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4490 }
4491 return resultobj;
4492 fail:
4493 return NULL;
4494 }
4495
4496
4497 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4498 PyObject *resultobj;
4499 char *kwnames[] = {
4500 NULL
4501 };
4502
4503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4504 {
4505 PyThreadState* __tstate = wxPyBeginAllowThreads();
4506 wxTrap();
4507
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 Py_INCREF(Py_None); resultobj = Py_None;
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj;
4520 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4521 wxString *arg1 = (wxString *) &arg1_defvalue ;
4522 wxString const &arg2_defvalue = wxPyEmptyString ;
4523 wxString *arg2 = (wxString *) &arg2_defvalue ;
4524 wxString const &arg3_defvalue = wxPyEmptyString ;
4525 wxString *arg3 = (wxString *) &arg3_defvalue ;
4526 wxString const &arg4_defvalue = wxPyEmptyString ;
4527 wxString *arg4 = (wxString *) &arg4_defvalue ;
4528 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4529 wxString *arg5 = (wxString *) &arg5_defvalue ;
4530 int arg6 = (int) 0 ;
4531 wxWindow *arg7 = (wxWindow *) NULL ;
4532 int arg8 = (int) -1 ;
4533 int arg9 = (int) -1 ;
4534 wxString result;
4535 bool temp1 = false ;
4536 bool temp2 = false ;
4537 bool temp3 = false ;
4538 bool temp4 = false ;
4539 bool temp5 = false ;
4540 PyObject * obj0 = 0 ;
4541 PyObject * obj1 = 0 ;
4542 PyObject * obj2 = 0 ;
4543 PyObject * obj3 = 0 ;
4544 PyObject * obj4 = 0 ;
4545 PyObject * obj5 = 0 ;
4546 PyObject * obj6 = 0 ;
4547 PyObject * obj7 = 0 ;
4548 PyObject * obj8 = 0 ;
4549 char *kwnames[] = {
4550 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4551 };
4552
4553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4554 if (obj0) {
4555 {
4556 arg1 = wxString_in_helper(obj0);
4557 if (arg1 == NULL) SWIG_fail;
4558 temp1 = true;
4559 }
4560 }
4561 if (obj1) {
4562 {
4563 arg2 = wxString_in_helper(obj1);
4564 if (arg2 == NULL) SWIG_fail;
4565 temp2 = true;
4566 }
4567 }
4568 if (obj2) {
4569 {
4570 arg3 = wxString_in_helper(obj2);
4571 if (arg3 == NULL) SWIG_fail;
4572 temp3 = true;
4573 }
4574 }
4575 if (obj3) {
4576 {
4577 arg4 = wxString_in_helper(obj3);
4578 if (arg4 == NULL) SWIG_fail;
4579 temp4 = true;
4580 }
4581 }
4582 if (obj4) {
4583 {
4584 arg5 = wxString_in_helper(obj4);
4585 if (arg5 == NULL) SWIG_fail;
4586 temp5 = true;
4587 }
4588 }
4589 if (obj5) {
4590 {
4591 arg6 = (int)(SWIG_As_int(obj5));
4592 if (SWIG_arg_fail(6)) SWIG_fail;
4593 }
4594 }
4595 if (obj6) {
4596 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4597 if (SWIG_arg_fail(7)) SWIG_fail;
4598 }
4599 if (obj7) {
4600 {
4601 arg8 = (int)(SWIG_As_int(obj7));
4602 if (SWIG_arg_fail(8)) SWIG_fail;
4603 }
4604 }
4605 if (obj8) {
4606 {
4607 arg9 = (int)(SWIG_As_int(obj8));
4608 if (SWIG_arg_fail(9)) SWIG_fail;
4609 }
4610 }
4611 {
4612 if (!wxPyCheckForApp()) SWIG_fail;
4613 PyThreadState* __tstate = wxPyBeginAllowThreads();
4614 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4615
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 {
4620 #if wxUSE_UNICODE
4621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4622 #else
4623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4624 #endif
4625 }
4626 {
4627 if (temp1)
4628 delete arg1;
4629 }
4630 {
4631 if (temp2)
4632 delete arg2;
4633 }
4634 {
4635 if (temp3)
4636 delete arg3;
4637 }
4638 {
4639 if (temp4)
4640 delete arg4;
4641 }
4642 {
4643 if (temp5)
4644 delete arg5;
4645 }
4646 return resultobj;
4647 fail:
4648 {
4649 if (temp1)
4650 delete arg1;
4651 }
4652 {
4653 if (temp2)
4654 delete arg2;
4655 }
4656 {
4657 if (temp3)
4658 delete arg3;
4659 }
4660 {
4661 if (temp4)
4662 delete arg4;
4663 }
4664 {
4665 if (temp5)
4666 delete arg5;
4667 }
4668 return NULL;
4669 }
4670
4671
4672 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj;
4674 wxString *arg1 = 0 ;
4675 wxString *arg2 = 0 ;
4676 wxString const &arg3_defvalue = wxPyEmptyString ;
4677 wxString *arg3 = (wxString *) &arg3_defvalue ;
4678 wxWindow *arg4 = (wxWindow *) NULL ;
4679 wxString result;
4680 bool temp1 = false ;
4681 bool temp2 = false ;
4682 bool temp3 = false ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 PyObject * obj2 = 0 ;
4686 PyObject * obj3 = 0 ;
4687 char *kwnames[] = {
4688 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4689 };
4690
4691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4692 {
4693 arg1 = wxString_in_helper(obj0);
4694 if (arg1 == NULL) SWIG_fail;
4695 temp1 = true;
4696 }
4697 {
4698 arg2 = wxString_in_helper(obj1);
4699 if (arg2 == NULL) SWIG_fail;
4700 temp2 = true;
4701 }
4702 if (obj2) {
4703 {
4704 arg3 = wxString_in_helper(obj2);
4705 if (arg3 == NULL) SWIG_fail;
4706 temp3 = true;
4707 }
4708 }
4709 if (obj3) {
4710 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(4)) SWIG_fail;
4712 }
4713 {
4714 if (!wxPyCheckForApp()) SWIG_fail;
4715 PyThreadState* __tstate = wxPyBeginAllowThreads();
4716 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4717
4718 wxPyEndAllowThreads(__tstate);
4719 if (PyErr_Occurred()) SWIG_fail;
4720 }
4721 {
4722 #if wxUSE_UNICODE
4723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4724 #else
4725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4726 #endif
4727 }
4728 {
4729 if (temp1)
4730 delete arg1;
4731 }
4732 {
4733 if (temp2)
4734 delete arg2;
4735 }
4736 {
4737 if (temp3)
4738 delete arg3;
4739 }
4740 return resultobj;
4741 fail:
4742 {
4743 if (temp1)
4744 delete arg1;
4745 }
4746 {
4747 if (temp2)
4748 delete arg2;
4749 }
4750 {
4751 if (temp3)
4752 delete arg3;
4753 }
4754 return NULL;
4755 }
4756
4757
4758 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4759 PyObject *resultobj;
4760 wxString *arg1 = 0 ;
4761 wxString *arg2 = 0 ;
4762 wxString const &arg3_defvalue = wxPyEmptyString ;
4763 wxString *arg3 = (wxString *) &arg3_defvalue ;
4764 wxWindow *arg4 = (wxWindow *) NULL ;
4765 wxString result;
4766 bool temp1 = false ;
4767 bool temp2 = false ;
4768 bool temp3 = false ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 PyObject * obj2 = 0 ;
4772 PyObject * obj3 = 0 ;
4773 char *kwnames[] = {
4774 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4775 };
4776
4777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4778 {
4779 arg1 = wxString_in_helper(obj0);
4780 if (arg1 == NULL) SWIG_fail;
4781 temp1 = true;
4782 }
4783 {
4784 arg2 = wxString_in_helper(obj1);
4785 if (arg2 == NULL) SWIG_fail;
4786 temp2 = true;
4787 }
4788 if (obj2) {
4789 {
4790 arg3 = wxString_in_helper(obj2);
4791 if (arg3 == NULL) SWIG_fail;
4792 temp3 = true;
4793 }
4794 }
4795 if (obj3) {
4796 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4797 if (SWIG_arg_fail(4)) SWIG_fail;
4798 }
4799 {
4800 if (!wxPyCheckForApp()) SWIG_fail;
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4803
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 {
4808 #if wxUSE_UNICODE
4809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4810 #else
4811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4812 #endif
4813 }
4814 {
4815 if (temp1)
4816 delete arg1;
4817 }
4818 {
4819 if (temp2)
4820 delete arg2;
4821 }
4822 {
4823 if (temp3)
4824 delete arg3;
4825 }
4826 return resultobj;
4827 fail:
4828 {
4829 if (temp1)
4830 delete arg1;
4831 }
4832 {
4833 if (temp2)
4834 delete arg2;
4835 }
4836 {
4837 if (temp3)
4838 delete arg3;
4839 }
4840 return NULL;
4841 }
4842
4843
4844 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4845 PyObject *resultobj;
4846 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4847 wxString *arg1 = (wxString *) &arg1_defvalue ;
4848 wxString const &arg2_defvalue = wxPyEmptyString ;
4849 wxString *arg2 = (wxString *) &arg2_defvalue ;
4850 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4851 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4852 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4853 wxWindow *arg5 = (wxWindow *) NULL ;
4854 wxString result;
4855 bool temp1 = false ;
4856 bool temp2 = false ;
4857 wxPoint temp4 ;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 PyObject * obj2 = 0 ;
4861 PyObject * obj3 = 0 ;
4862 PyObject * obj4 = 0 ;
4863 char *kwnames[] = {
4864 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4865 };
4866
4867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4868 if (obj0) {
4869 {
4870 arg1 = wxString_in_helper(obj0);
4871 if (arg1 == NULL) SWIG_fail;
4872 temp1 = true;
4873 }
4874 }
4875 if (obj1) {
4876 {
4877 arg2 = wxString_in_helper(obj1);
4878 if (arg2 == NULL) SWIG_fail;
4879 temp2 = true;
4880 }
4881 }
4882 if (obj2) {
4883 {
4884 arg3 = (long)(SWIG_As_long(obj2));
4885 if (SWIG_arg_fail(3)) SWIG_fail;
4886 }
4887 }
4888 if (obj3) {
4889 {
4890 arg4 = &temp4;
4891 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4892 }
4893 }
4894 if (obj4) {
4895 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4896 if (SWIG_arg_fail(5)) SWIG_fail;
4897 }
4898 {
4899 if (!wxPyCheckForApp()) SWIG_fail;
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4902
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 {
4907 #if wxUSE_UNICODE
4908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4909 #else
4910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4911 #endif
4912 }
4913 {
4914 if (temp1)
4915 delete arg1;
4916 }
4917 {
4918 if (temp2)
4919 delete arg2;
4920 }
4921 return resultobj;
4922 fail:
4923 {
4924 if (temp1)
4925 delete arg1;
4926 }
4927 {
4928 if (temp2)
4929 delete arg2;
4930 }
4931 return NULL;
4932 }
4933
4934
4935 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4936 PyObject *resultobj;
4937 wxString *arg1 = 0 ;
4938 wxString const &arg2_defvalue = wxPyEmptyString ;
4939 wxString *arg2 = (wxString *) &arg2_defvalue ;
4940 wxString const &arg3_defvalue = wxPyEmptyString ;
4941 wxString *arg3 = (wxString *) &arg3_defvalue ;
4942 wxWindow *arg4 = (wxWindow *) NULL ;
4943 int arg5 = (int) -1 ;
4944 int arg6 = (int) -1 ;
4945 bool arg7 = (bool) true ;
4946 wxString result;
4947 bool temp1 = false ;
4948 bool temp2 = false ;
4949 bool temp3 = false ;
4950 PyObject * obj0 = 0 ;
4951 PyObject * obj1 = 0 ;
4952 PyObject * obj2 = 0 ;
4953 PyObject * obj3 = 0 ;
4954 PyObject * obj4 = 0 ;
4955 PyObject * obj5 = 0 ;
4956 PyObject * obj6 = 0 ;
4957 char *kwnames[] = {
4958 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4959 };
4960
4961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4962 {
4963 arg1 = wxString_in_helper(obj0);
4964 if (arg1 == NULL) SWIG_fail;
4965 temp1 = true;
4966 }
4967 if (obj1) {
4968 {
4969 arg2 = wxString_in_helper(obj1);
4970 if (arg2 == NULL) SWIG_fail;
4971 temp2 = true;
4972 }
4973 }
4974 if (obj2) {
4975 {
4976 arg3 = wxString_in_helper(obj2);
4977 if (arg3 == NULL) SWIG_fail;
4978 temp3 = true;
4979 }
4980 }
4981 if (obj3) {
4982 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4983 if (SWIG_arg_fail(4)) SWIG_fail;
4984 }
4985 if (obj4) {
4986 {
4987 arg5 = (int)(SWIG_As_int(obj4));
4988 if (SWIG_arg_fail(5)) SWIG_fail;
4989 }
4990 }
4991 if (obj5) {
4992 {
4993 arg6 = (int)(SWIG_As_int(obj5));
4994 if (SWIG_arg_fail(6)) SWIG_fail;
4995 }
4996 }
4997 if (obj6) {
4998 {
4999 arg7 = (bool)(SWIG_As_bool(obj6));
5000 if (SWIG_arg_fail(7)) SWIG_fail;
5001 }
5002 }
5003 {
5004 if (!wxPyCheckForApp()) SWIG_fail;
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 {
5012 #if wxUSE_UNICODE
5013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5014 #else
5015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5016 #endif
5017 }
5018 {
5019 if (temp1)
5020 delete arg1;
5021 }
5022 {
5023 if (temp2)
5024 delete arg2;
5025 }
5026 {
5027 if (temp3)
5028 delete arg3;
5029 }
5030 return resultobj;
5031 fail:
5032 {
5033 if (temp1)
5034 delete arg1;
5035 }
5036 {
5037 if (temp2)
5038 delete arg2;
5039 }
5040 {
5041 if (temp3)
5042 delete arg3;
5043 }
5044 return NULL;
5045 }
5046
5047
5048 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5049 PyObject *resultobj;
5050 wxString *arg1 = 0 ;
5051 wxString const &arg2_defvalue = wxPyEmptyString ;
5052 wxString *arg2 = (wxString *) &arg2_defvalue ;
5053 wxString const &arg3_defvalue = wxPyEmptyString ;
5054 wxString *arg3 = (wxString *) &arg3_defvalue ;
5055 wxWindow *arg4 = (wxWindow *) NULL ;
5056 wxString result;
5057 bool temp1 = false ;
5058 bool temp2 = false ;
5059 bool temp3 = false ;
5060 PyObject * obj0 = 0 ;
5061 PyObject * obj1 = 0 ;
5062 PyObject * obj2 = 0 ;
5063 PyObject * obj3 = 0 ;
5064 char *kwnames[] = {
5065 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5066 };
5067
5068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5069 {
5070 arg1 = wxString_in_helper(obj0);
5071 if (arg1 == NULL) SWIG_fail;
5072 temp1 = true;
5073 }
5074 if (obj1) {
5075 {
5076 arg2 = wxString_in_helper(obj1);
5077 if (arg2 == NULL) SWIG_fail;
5078 temp2 = true;
5079 }
5080 }
5081 if (obj2) {
5082 {
5083 arg3 = wxString_in_helper(obj2);
5084 if (arg3 == NULL) SWIG_fail;
5085 temp3 = true;
5086 }
5087 }
5088 if (obj3) {
5089 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5090 if (SWIG_arg_fail(4)) SWIG_fail;
5091 }
5092 {
5093 if (!wxPyCheckForApp()) SWIG_fail;
5094 PyThreadState* __tstate = wxPyBeginAllowThreads();
5095 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5096
5097 wxPyEndAllowThreads(__tstate);
5098 if (PyErr_Occurred()) SWIG_fail;
5099 }
5100 {
5101 #if wxUSE_UNICODE
5102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5103 #else
5104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5105 #endif
5106 }
5107 {
5108 if (temp1)
5109 delete arg1;
5110 }
5111 {
5112 if (temp2)
5113 delete arg2;
5114 }
5115 {
5116 if (temp3)
5117 delete arg3;
5118 }
5119 return resultobj;
5120 fail:
5121 {
5122 if (temp1)
5123 delete arg1;
5124 }
5125 {
5126 if (temp2)
5127 delete arg2;
5128 }
5129 {
5130 if (temp3)
5131 delete arg3;
5132 }
5133 return NULL;
5134 }
5135
5136
5137 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5138 PyObject *resultobj;
5139 wxString *arg1 = 0 ;
5140 wxString *arg2 = 0 ;
5141 int arg3 ;
5142 wxString *arg4 = (wxString *) 0 ;
5143 wxWindow *arg5 = (wxWindow *) NULL ;
5144 int arg6 = (int) -1 ;
5145 int arg7 = (int) -1 ;
5146 bool arg8 = (bool) true ;
5147 int arg9 = (int) 150 ;
5148 int arg10 = (int) 200 ;
5149 wxString result;
5150 bool temp1 = false ;
5151 bool temp2 = false ;
5152 PyObject * obj0 = 0 ;
5153 PyObject * obj1 = 0 ;
5154 PyObject * obj2 = 0 ;
5155 PyObject * obj3 = 0 ;
5156 PyObject * obj4 = 0 ;
5157 PyObject * obj5 = 0 ;
5158 PyObject * obj6 = 0 ;
5159 PyObject * obj7 = 0 ;
5160 PyObject * obj8 = 0 ;
5161 char *kwnames[] = {
5162 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5163 };
5164
5165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5166 {
5167 arg1 = wxString_in_helper(obj0);
5168 if (arg1 == NULL) SWIG_fail;
5169 temp1 = true;
5170 }
5171 {
5172 arg2 = wxString_in_helper(obj1);
5173 if (arg2 == NULL) SWIG_fail;
5174 temp2 = true;
5175 }
5176 {
5177 arg3 = PyList_Size(obj2);
5178 arg4 = wxString_LIST_helper(obj2);
5179 if (arg4 == NULL) SWIG_fail;
5180 }
5181 if (obj3) {
5182 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5183 if (SWIG_arg_fail(5)) SWIG_fail;
5184 }
5185 if (obj4) {
5186 {
5187 arg6 = (int)(SWIG_As_int(obj4));
5188 if (SWIG_arg_fail(6)) SWIG_fail;
5189 }
5190 }
5191 if (obj5) {
5192 {
5193 arg7 = (int)(SWIG_As_int(obj5));
5194 if (SWIG_arg_fail(7)) SWIG_fail;
5195 }
5196 }
5197 if (obj6) {
5198 {
5199 arg8 = (bool)(SWIG_As_bool(obj6));
5200 if (SWIG_arg_fail(8)) SWIG_fail;
5201 }
5202 }
5203 if (obj7) {
5204 {
5205 arg9 = (int)(SWIG_As_int(obj7));
5206 if (SWIG_arg_fail(9)) SWIG_fail;
5207 }
5208 }
5209 if (obj8) {
5210 {
5211 arg10 = (int)(SWIG_As_int(obj8));
5212 if (SWIG_arg_fail(10)) SWIG_fail;
5213 }
5214 }
5215 {
5216 if (!wxPyCheckForApp()) SWIG_fail;
5217 PyThreadState* __tstate = wxPyBeginAllowThreads();
5218 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5219
5220 wxPyEndAllowThreads(__tstate);
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 {
5224 #if wxUSE_UNICODE
5225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5226 #else
5227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5228 #endif
5229 }
5230 {
5231 if (temp1)
5232 delete arg1;
5233 }
5234 {
5235 if (temp2)
5236 delete arg2;
5237 }
5238 {
5239 if (arg4) delete [] arg4;
5240 }
5241 return resultobj;
5242 fail:
5243 {
5244 if (temp1)
5245 delete arg1;
5246 }
5247 {
5248 if (temp2)
5249 delete arg2;
5250 }
5251 {
5252 if (arg4) delete [] arg4;
5253 }
5254 return NULL;
5255 }
5256
5257
5258 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj;
5260 wxString *arg1 = 0 ;
5261 wxString *arg2 = 0 ;
5262 int arg3 ;
5263 wxString *arg4 = (wxString *) 0 ;
5264 wxWindow *arg5 = (wxWindow *) NULL ;
5265 int arg6 = (int) -1 ;
5266 int arg7 = (int) -1 ;
5267 bool arg8 = (bool) true ;
5268 int arg9 = (int) 150 ;
5269 int arg10 = (int) 200 ;
5270 int result;
5271 bool temp1 = false ;
5272 bool temp2 = false ;
5273 PyObject * obj0 = 0 ;
5274 PyObject * obj1 = 0 ;
5275 PyObject * obj2 = 0 ;
5276 PyObject * obj3 = 0 ;
5277 PyObject * obj4 = 0 ;
5278 PyObject * obj5 = 0 ;
5279 PyObject * obj6 = 0 ;
5280 PyObject * obj7 = 0 ;
5281 PyObject * obj8 = 0 ;
5282 char *kwnames[] = {
5283 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5284 };
5285
5286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5287 {
5288 arg1 = wxString_in_helper(obj0);
5289 if (arg1 == NULL) SWIG_fail;
5290 temp1 = true;
5291 }
5292 {
5293 arg2 = wxString_in_helper(obj1);
5294 if (arg2 == NULL) SWIG_fail;
5295 temp2 = true;
5296 }
5297 {
5298 arg3 = PyList_Size(obj2);
5299 arg4 = wxString_LIST_helper(obj2);
5300 if (arg4 == NULL) SWIG_fail;
5301 }
5302 if (obj3) {
5303 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5304 if (SWIG_arg_fail(5)) SWIG_fail;
5305 }
5306 if (obj4) {
5307 {
5308 arg6 = (int)(SWIG_As_int(obj4));
5309 if (SWIG_arg_fail(6)) SWIG_fail;
5310 }
5311 }
5312 if (obj5) {
5313 {
5314 arg7 = (int)(SWIG_As_int(obj5));
5315 if (SWIG_arg_fail(7)) SWIG_fail;
5316 }
5317 }
5318 if (obj6) {
5319 {
5320 arg8 = (bool)(SWIG_As_bool(obj6));
5321 if (SWIG_arg_fail(8)) SWIG_fail;
5322 }
5323 }
5324 if (obj7) {
5325 {
5326 arg9 = (int)(SWIG_As_int(obj7));
5327 if (SWIG_arg_fail(9)) SWIG_fail;
5328 }
5329 }
5330 if (obj8) {
5331 {
5332 arg10 = (int)(SWIG_As_int(obj8));
5333 if (SWIG_arg_fail(10)) SWIG_fail;
5334 }
5335 }
5336 {
5337 if (!wxPyCheckForApp()) SWIG_fail;
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5340
5341 wxPyEndAllowThreads(__tstate);
5342 if (PyErr_Occurred()) SWIG_fail;
5343 }
5344 {
5345 resultobj = SWIG_From_int((int)(result));
5346 }
5347 {
5348 if (temp1)
5349 delete arg1;
5350 }
5351 {
5352 if (temp2)
5353 delete arg2;
5354 }
5355 {
5356 if (arg4) delete [] arg4;
5357 }
5358 return resultobj;
5359 fail:
5360 {
5361 if (temp1)
5362 delete arg1;
5363 }
5364 {
5365 if (temp2)
5366 delete arg2;
5367 }
5368 {
5369 if (arg4) delete [] arg4;
5370 }
5371 return NULL;
5372 }
5373
5374
5375 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5376 PyObject *resultobj;
5377 wxString *arg1 = 0 ;
5378 wxString const &arg2_defvalue = wxPyEmptyString ;
5379 wxString *arg2 = (wxString *) &arg2_defvalue ;
5380 int arg3 = (int) wxOK|wxCENTRE ;
5381 wxWindow *arg4 = (wxWindow *) NULL ;
5382 int arg5 = (int) -1 ;
5383 int arg6 = (int) -1 ;
5384 int result;
5385 bool temp1 = false ;
5386 bool temp2 = false ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 PyObject * obj2 = 0 ;
5390 PyObject * obj3 = 0 ;
5391 PyObject * obj4 = 0 ;
5392 PyObject * obj5 = 0 ;
5393 char *kwnames[] = {
5394 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5395 };
5396
5397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5398 {
5399 arg1 = wxString_in_helper(obj0);
5400 if (arg1 == NULL) SWIG_fail;
5401 temp1 = true;
5402 }
5403 if (obj1) {
5404 {
5405 arg2 = wxString_in_helper(obj1);
5406 if (arg2 == NULL) SWIG_fail;
5407 temp2 = true;
5408 }
5409 }
5410 if (obj2) {
5411 {
5412 arg3 = (int)(SWIG_As_int(obj2));
5413 if (SWIG_arg_fail(3)) SWIG_fail;
5414 }
5415 }
5416 if (obj3) {
5417 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5418 if (SWIG_arg_fail(4)) SWIG_fail;
5419 }
5420 if (obj4) {
5421 {
5422 arg5 = (int)(SWIG_As_int(obj4));
5423 if (SWIG_arg_fail(5)) SWIG_fail;
5424 }
5425 }
5426 if (obj5) {
5427 {
5428 arg6 = (int)(SWIG_As_int(obj5));
5429 if (SWIG_arg_fail(6)) SWIG_fail;
5430 }
5431 }
5432 {
5433 if (!wxPyCheckForApp()) SWIG_fail;
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5436
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 {
5441 resultobj = SWIG_From_int((int)(result));
5442 }
5443 {
5444 if (temp1)
5445 delete arg1;
5446 }
5447 {
5448 if (temp2)
5449 delete arg2;
5450 }
5451 return resultobj;
5452 fail:
5453 {
5454 if (temp1)
5455 delete arg1;
5456 }
5457 {
5458 if (temp2)
5459 delete arg2;
5460 }
5461 return NULL;
5462 }
5463
5464
5465 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5466 PyObject *resultobj;
5467 wxString *arg1 = 0 ;
5468 wxString *arg2 = 0 ;
5469 wxString *arg3 = 0 ;
5470 long arg4 ;
5471 long arg5 = (long) 0 ;
5472 long arg6 = (long) 100 ;
5473 wxWindow *arg7 = (wxWindow *) NULL ;
5474 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5475 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5476 long result;
5477 bool temp1 = false ;
5478 bool temp2 = false ;
5479 bool temp3 = false ;
5480 wxPoint temp8 ;
5481 PyObject * obj0 = 0 ;
5482 PyObject * obj1 = 0 ;
5483 PyObject * obj2 = 0 ;
5484 PyObject * obj3 = 0 ;
5485 PyObject * obj4 = 0 ;
5486 PyObject * obj5 = 0 ;
5487 PyObject * obj6 = 0 ;
5488 PyObject * obj7 = 0 ;
5489 char *kwnames[] = {
5490 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5491 };
5492
5493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5494 {
5495 arg1 = wxString_in_helper(obj0);
5496 if (arg1 == NULL) SWIG_fail;
5497 temp1 = true;
5498 }
5499 {
5500 arg2 = wxString_in_helper(obj1);
5501 if (arg2 == NULL) SWIG_fail;
5502 temp2 = true;
5503 }
5504 {
5505 arg3 = wxString_in_helper(obj2);
5506 if (arg3 == NULL) SWIG_fail;
5507 temp3 = true;
5508 }
5509 {
5510 arg4 = (long)(SWIG_As_long(obj3));
5511 if (SWIG_arg_fail(4)) SWIG_fail;
5512 }
5513 if (obj4) {
5514 {
5515 arg5 = (long)(SWIG_As_long(obj4));
5516 if (SWIG_arg_fail(5)) SWIG_fail;
5517 }
5518 }
5519 if (obj5) {
5520 {
5521 arg6 = (long)(SWIG_As_long(obj5));
5522 if (SWIG_arg_fail(6)) SWIG_fail;
5523 }
5524 }
5525 if (obj6) {
5526 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5527 if (SWIG_arg_fail(7)) SWIG_fail;
5528 }
5529 if (obj7) {
5530 {
5531 arg8 = &temp8;
5532 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5533 }
5534 }
5535 {
5536 if (!wxPyCheckForApp()) SWIG_fail;
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5539
5540 wxPyEndAllowThreads(__tstate);
5541 if (PyErr_Occurred()) SWIG_fail;
5542 }
5543 {
5544 resultobj = SWIG_From_long((long)(result));
5545 }
5546 {
5547 if (temp1)
5548 delete arg1;
5549 }
5550 {
5551 if (temp2)
5552 delete arg2;
5553 }
5554 {
5555 if (temp3)
5556 delete arg3;
5557 }
5558 return resultobj;
5559 fail:
5560 {
5561 if (temp1)
5562 delete arg1;
5563 }
5564 {
5565 if (temp2)
5566 delete arg2;
5567 }
5568 {
5569 if (temp3)
5570 delete arg3;
5571 }
5572 return NULL;
5573 }
5574
5575
5576 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5577 PyObject *resultobj;
5578 bool result;
5579 char *kwnames[] = {
5580 NULL
5581 };
5582
5583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5584 {
5585 if (!wxPyCheckForApp()) SWIG_fail;
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = (bool)wxColourDisplay();
5588
5589 wxPyEndAllowThreads(__tstate);
5590 if (PyErr_Occurred()) SWIG_fail;
5591 }
5592 {
5593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5594 }
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj;
5603 int result;
5604 char *kwnames[] = {
5605 NULL
5606 };
5607
5608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5609 {
5610 if (!wxPyCheckForApp()) SWIG_fail;
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 result = (int)wxDisplayDepth();
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 {
5618 resultobj = SWIG_From_int((int)(result));
5619 }
5620 return resultobj;
5621 fail:
5622 return NULL;
5623 }
5624
5625
5626 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5627 PyObject *resultobj;
5628 int result;
5629 char *kwnames[] = {
5630 NULL
5631 };
5632
5633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5634 {
5635 if (!wxPyCheckForApp()) SWIG_fail;
5636 PyThreadState* __tstate = wxPyBeginAllowThreads();
5637 result = (int)wxGetDisplayDepth();
5638
5639 wxPyEndAllowThreads(__tstate);
5640 if (PyErr_Occurred()) SWIG_fail;
5641 }
5642 {
5643 resultobj = SWIG_From_int((int)(result));
5644 }
5645 return resultobj;
5646 fail:
5647 return NULL;
5648 }
5649
5650
5651 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5652 PyObject *resultobj;
5653 int *arg1 = (int *) 0 ;
5654 int *arg2 = (int *) 0 ;
5655 int temp1 ;
5656 int res1 = 0 ;
5657 int temp2 ;
5658 int res2 = 0 ;
5659 char *kwnames[] = {
5660 NULL
5661 };
5662
5663 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5664 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5666 {
5667 if (!wxPyCheckForApp()) SWIG_fail;
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 wxDisplaySize(arg1,arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5676 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5677 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5678 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj;
5687 wxSize result;
5688 char *kwnames[] = {
5689 NULL
5690 };
5691
5692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5693 {
5694 if (!wxPyCheckForApp()) SWIG_fail;
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = wxGetDisplaySize();
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 {
5702 wxSize * resultptr;
5703 resultptr = new wxSize((wxSize &)(result));
5704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5705 }
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 int *arg1 = (int *) 0 ;
5715 int *arg2 = (int *) 0 ;
5716 int temp1 ;
5717 int res1 = 0 ;
5718 int temp2 ;
5719 int res2 = 0 ;
5720 char *kwnames[] = {
5721 NULL
5722 };
5723
5724 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5725 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5727 {
5728 if (!wxPyCheckForApp()) SWIG_fail;
5729 PyThreadState* __tstate = wxPyBeginAllowThreads();
5730 wxDisplaySizeMM(arg1,arg2);
5731
5732 wxPyEndAllowThreads(__tstate);
5733 if (PyErr_Occurred()) SWIG_fail;
5734 }
5735 Py_INCREF(Py_None); resultobj = Py_None;
5736 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5737 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5738 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5739 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
5746 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj;
5748 wxSize result;
5749 char *kwnames[] = {
5750 NULL
5751 };
5752
5753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5754 {
5755 if (!wxPyCheckForApp()) SWIG_fail;
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 result = wxGetDisplaySizeMM();
5758
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 {
5763 wxSize * resultptr;
5764 resultptr = new wxSize((wxSize &)(result));
5765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5766 }
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5774 PyObject *resultobj;
5775 int *arg1 = (int *) 0 ;
5776 int *arg2 = (int *) 0 ;
5777 int *arg3 = (int *) 0 ;
5778 int *arg4 = (int *) 0 ;
5779 int temp1 ;
5780 int res1 = 0 ;
5781 int temp2 ;
5782 int res2 = 0 ;
5783 int temp3 ;
5784 int res3 = 0 ;
5785 int temp4 ;
5786 int res4 = 0 ;
5787 char *kwnames[] = {
5788 NULL
5789 };
5790
5791 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5792 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5793 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5794 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5796 {
5797 if (!wxPyCheckForApp()) SWIG_fail;
5798 PyThreadState* __tstate = wxPyBeginAllowThreads();
5799 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5800
5801 wxPyEndAllowThreads(__tstate);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 Py_INCREF(Py_None); resultobj = Py_None;
5805 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5806 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5807 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5808 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5809 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5810 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5811 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5812 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5813 return resultobj;
5814 fail:
5815 return NULL;
5816 }
5817
5818
5819 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5820 PyObject *resultobj;
5821 wxRect result;
5822 char *kwnames[] = {
5823 NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5827 {
5828 if (!wxPyCheckForApp()) SWIG_fail;
5829 PyThreadState* __tstate = wxPyBeginAllowThreads();
5830 result = wxGetClientDisplayRect();
5831
5832 wxPyEndAllowThreads(__tstate);
5833 if (PyErr_Occurred()) SWIG_fail;
5834 }
5835 {
5836 wxRect * resultptr;
5837 resultptr = new wxRect((wxRect &)(result));
5838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxCursor *arg1 = 0 ;
5849 PyObject * obj0 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "cursor", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5855 {
5856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5857 if (SWIG_arg_fail(1)) SWIG_fail;
5858 if (arg1 == NULL) {
5859 SWIG_null_ref("wxCursor");
5860 }
5861 if (SWIG_arg_fail(1)) SWIG_fail;
5862 }
5863 {
5864 if (!wxPyCheckForApp()) SWIG_fail;
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 wxSetCursor(*arg1);
5867
5868 wxPyEndAllowThreads(__tstate);
5869 if (PyErr_Occurred()) SWIG_fail;
5870 }
5871 Py_INCREF(Py_None); resultobj = Py_None;
5872 return resultobj;
5873 fail:
5874 return NULL;
5875 }
5876
5877
5878 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5879 PyObject *resultobj;
5880 void *result;
5881 char *kwnames[] = {
5882 NULL
5883 };
5884
5885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5886 {
5887 if (!wxPyCheckForApp()) SWIG_fail;
5888 PyThreadState* __tstate = wxPyBeginAllowThreads();
5889 result = (void *)wxGetXDisplay();
5890
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj;
5903 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5904 PyObject * obj0 = 0 ;
5905 char *kwnames[] = {
5906 (char *) "cursor", NULL
5907 };
5908
5909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5910 if (obj0) {
5911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5912 if (SWIG_arg_fail(1)) SWIG_fail;
5913 }
5914 {
5915 if (!wxPyCheckForApp()) SWIG_fail;
5916 PyThreadState* __tstate = wxPyBeginAllowThreads();
5917 wxBeginBusyCursor(arg1);
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_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj;
5931 wxWindow *result;
5932 char *kwnames[] = {
5933 NULL
5934 };
5935
5936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5937 {
5938 if (!wxPyCheckForApp()) SWIG_fail;
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 result = (wxWindow *)wxGetActiveWindow();
5941
5942 wxPyEndAllowThreads(__tstate);
5943 if (PyErr_Occurred()) SWIG_fail;
5944 }
5945 {
5946 resultobj = wxPyMake_wxObject(result, 0);
5947 }
5948 return resultobj;
5949 fail:
5950 return NULL;
5951 }
5952
5953
5954 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5955 PyObject *resultobj;
5956 wxPoint *arg1 = 0 ;
5957 wxWindow *result;
5958 wxPoint temp1 ;
5959 PyObject * obj0 = 0 ;
5960 char *kwnames[] = {
5961 (char *) "pt", NULL
5962 };
5963
5964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5965 {
5966 arg1 = &temp1;
5967 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5968 }
5969 {
5970 if (!wxPyCheckForApp()) SWIG_fail;
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5973
5974 wxPyEndAllowThreads(__tstate);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 {
5978 resultobj = wxPyMake_wxObject(result, 0);
5979 }
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj;
5988 wxPoint *arg1 = 0 ;
5989 wxWindow *result;
5990 wxPoint temp1 ;
5991 PyObject * obj0 = 0 ;
5992 char *kwnames[] = {
5993 (char *) "pt", NULL
5994 };
5995
5996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5997 {
5998 arg1 = &temp1;
5999 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6000 }
6001 {
6002 if (!wxPyCheckForApp()) SWIG_fail;
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6005
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 {
6010 resultobj = wxPyMake_wxObject(result, 0);
6011 }
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj;
6020 wxWindow *arg1 = (wxWindow *) 0 ;
6021 wxWindow *result;
6022 PyObject * obj0 = 0 ;
6023 char *kwnames[] = {
6024 (char *) "win", NULL
6025 };
6026
6027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6029 if (SWIG_arg_fail(1)) SWIG_fail;
6030 {
6031 if (!wxPyCheckForApp()) SWIG_fail;
6032 PyThreadState* __tstate = wxPyBeginAllowThreads();
6033 result = (wxWindow *)wxGetTopLevelParent(arg1);
6034
6035 wxPyEndAllowThreads(__tstate);
6036 if (PyErr_Occurred()) SWIG_fail;
6037 }
6038 {
6039 resultobj = wxPyMake_wxObject(result, 0);
6040 }
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj;
6049 wxString *arg1 = 0 ;
6050 bool result;
6051 bool temp1 = false ;
6052 PyObject * obj0 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "url", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6058 {
6059 arg1 = wxString_in_helper(obj0);
6060 if (arg1 == NULL) SWIG_fail;
6061 temp1 = true;
6062 }
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6066
6067 wxPyEndAllowThreads(__tstate);
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 {
6071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6072 }
6073 {
6074 if (temp1)
6075 delete arg1;
6076 }
6077 return resultobj;
6078 fail:
6079 {
6080 if (temp1)
6081 delete arg1;
6082 }
6083 return NULL;
6084 }
6085
6086
6087 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj;
6089 wxKeyCode arg1 ;
6090 bool result;
6091 PyObject * obj0 = 0 ;
6092 char *kwnames[] = {
6093 (char *) "key", NULL
6094 };
6095
6096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6097 {
6098 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6099 if (SWIG_arg_fail(1)) SWIG_fail;
6100 }
6101 {
6102 if (!wxPyCheckForApp()) SWIG_fail;
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6105
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 {
6110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6111 }
6112 return resultobj;
6113 fail:
6114 return NULL;
6115 }
6116
6117
6118 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6119 PyObject *resultobj;
6120 char *kwnames[] = {
6121 NULL
6122 };
6123
6124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6125 {
6126 if (!wxPyCheckForApp()) SWIG_fail;
6127 PyThreadState* __tstate = wxPyBeginAllowThreads();
6128 wxWakeUpMainThread();
6129
6130 wxPyEndAllowThreads(__tstate);
6131 if (PyErr_Occurred()) SWIG_fail;
6132 }
6133 Py_INCREF(Py_None); resultobj = Py_None;
6134 return resultobj;
6135 fail:
6136 return NULL;
6137 }
6138
6139
6140 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6141 PyObject *resultobj;
6142 char *kwnames[] = {
6143 NULL
6144 };
6145
6146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6147 {
6148 if (!wxPyCheckForApp()) SWIG_fail;
6149 PyThreadState* __tstate = wxPyBeginAllowThreads();
6150 wxMutexGuiEnter();
6151
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 Py_INCREF(Py_None); resultobj = Py_None;
6156 return resultobj;
6157 fail:
6158 return NULL;
6159 }
6160
6161
6162 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6163 PyObject *resultobj;
6164 char *kwnames[] = {
6165 NULL
6166 };
6167
6168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6169 {
6170 if (!wxPyCheckForApp()) SWIG_fail;
6171 PyThreadState* __tstate = wxPyBeginAllowThreads();
6172 wxMutexGuiLeave();
6173
6174 wxPyEndAllowThreads(__tstate);
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 Py_INCREF(Py_None); resultobj = Py_None;
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj;
6186 wxMutexGuiLocker *result;
6187 char *kwnames[] = {
6188 NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6192 {
6193 if (!wxPyCheckForApp()) SWIG_fail;
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj;
6209 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6210 PyObject * obj0 = 0 ;
6211 char *kwnames[] = {
6212 (char *) "self", NULL
6213 };
6214
6215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6217 if (SWIG_arg_fail(1)) SWIG_fail;
6218 {
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 delete arg1;
6221
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 Py_INCREF(Py_None); resultobj = Py_None;
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6233 PyObject *obj;
6234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6235 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6236 Py_INCREF(obj);
6237 return Py_BuildValue((char *)"");
6238 }
6239 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 bool result;
6242 char *kwnames[] = {
6243 NULL
6244 };
6245
6246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6247 {
6248 PyThreadState* __tstate = wxPyBeginAllowThreads();
6249 result = (bool)wxThread_IsMain();
6250
6251 wxPyEndAllowThreads(__tstate);
6252 if (PyErr_Occurred()) SWIG_fail;
6253 }
6254 {
6255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6256 }
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6264 PyObject *resultobj;
6265 wxString *arg1 = 0 ;
6266 wxToolTip *result;
6267 bool temp1 = false ;
6268 PyObject * obj0 = 0 ;
6269 char *kwnames[] = {
6270 (char *) "tip", NULL
6271 };
6272
6273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6274 {
6275 arg1 = wxString_in_helper(obj0);
6276 if (arg1 == NULL) SWIG_fail;
6277 temp1 = true;
6278 }
6279 {
6280 if (!wxPyCheckForApp()) SWIG_fail;
6281 PyThreadState* __tstate = wxPyBeginAllowThreads();
6282 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6283
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 {
6288 resultobj = wxPyMake_wxObject(result, 1);
6289 }
6290 {
6291 if (temp1)
6292 delete arg1;
6293 }
6294 return resultobj;
6295 fail:
6296 {
6297 if (temp1)
6298 delete arg1;
6299 }
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxToolTip *arg1 = (wxToolTip *) 0 ;
6307 wxString *arg2 = 0 ;
6308 bool temp2 = false ;
6309 PyObject * obj0 = 0 ;
6310 PyObject * obj1 = 0 ;
6311 char *kwnames[] = {
6312 (char *) "self",(char *) "tip", NULL
6313 };
6314
6315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6317 if (SWIG_arg_fail(1)) SWIG_fail;
6318 {
6319 arg2 = wxString_in_helper(obj1);
6320 if (arg2 == NULL) SWIG_fail;
6321 temp2 = true;
6322 }
6323 {
6324 PyThreadState* __tstate = wxPyBeginAllowThreads();
6325 (arg1)->SetTip((wxString const &)*arg2);
6326
6327 wxPyEndAllowThreads(__tstate);
6328 if (PyErr_Occurred()) SWIG_fail;
6329 }
6330 Py_INCREF(Py_None); resultobj = Py_None;
6331 {
6332 if (temp2)
6333 delete arg2;
6334 }
6335 return resultobj;
6336 fail:
6337 {
6338 if (temp2)
6339 delete arg2;
6340 }
6341 return NULL;
6342 }
6343
6344
6345 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6346 PyObject *resultobj;
6347 wxToolTip *arg1 = (wxToolTip *) 0 ;
6348 wxString result;
6349 PyObject * obj0 = 0 ;
6350 char *kwnames[] = {
6351 (char *) "self", NULL
6352 };
6353
6354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6356 if (SWIG_arg_fail(1)) SWIG_fail;
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (arg1)->GetTip();
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 {
6365 #if wxUSE_UNICODE
6366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6367 #else
6368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6369 #endif
6370 }
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj;
6379 wxToolTip *arg1 = (wxToolTip *) 0 ;
6380 wxWindow *result;
6381 PyObject * obj0 = 0 ;
6382 char *kwnames[] = {
6383 (char *) "self", NULL
6384 };
6385
6386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6388 if (SWIG_arg_fail(1)) SWIG_fail;
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 result = (wxWindow *)(arg1)->GetWindow();
6392
6393 wxPyEndAllowThreads(__tstate);
6394 if (PyErr_Occurred()) SWIG_fail;
6395 }
6396 {
6397 resultobj = wxPyMake_wxObject(result, 0);
6398 }
6399 return resultobj;
6400 fail:
6401 return NULL;
6402 }
6403
6404
6405 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj;
6407 bool arg1 ;
6408 PyObject * obj0 = 0 ;
6409 char *kwnames[] = {
6410 (char *) "flag", NULL
6411 };
6412
6413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6414 {
6415 arg1 = (bool)(SWIG_As_bool(obj0));
6416 if (SWIG_arg_fail(1)) SWIG_fail;
6417 }
6418 {
6419 PyThreadState* __tstate = wxPyBeginAllowThreads();
6420 wxToolTip::Enable(arg1);
6421
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 Py_INCREF(Py_None); resultobj = Py_None;
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj;
6434 long arg1 ;
6435 PyObject * obj0 = 0 ;
6436 char *kwnames[] = {
6437 (char *) "milliseconds", NULL
6438 };
6439
6440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6441 {
6442 arg1 = (long)(SWIG_As_long(obj0));
6443 if (SWIG_arg_fail(1)) SWIG_fail;
6444 }
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 wxToolTip::SetDelay(arg1);
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 Py_INCREF(Py_None); resultobj = Py_None;
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6460 PyObject *obj;
6461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6462 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6463 Py_INCREF(obj);
6464 return Py_BuildValue((char *)"");
6465 }
6466 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxWindow *arg1 = (wxWindow *) 0 ;
6469 wxSize *arg2 = 0 ;
6470 wxCaret *result;
6471 wxSize temp2 ;
6472 PyObject * obj0 = 0 ;
6473 PyObject * obj1 = 0 ;
6474 char *kwnames[] = {
6475 (char *) "window",(char *) "size", NULL
6476 };
6477
6478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6480 if (SWIG_arg_fail(1)) SWIG_fail;
6481 {
6482 arg2 = &temp2;
6483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6484 }
6485 {
6486 if (!wxPyCheckForApp()) SWIG_fail;
6487 PyThreadState* __tstate = wxPyBeginAllowThreads();
6488 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6489
6490 wxPyEndAllowThreads(__tstate);
6491 if (PyErr_Occurred()) SWIG_fail;
6492 }
6493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6494 return resultobj;
6495 fail:
6496 return NULL;
6497 }
6498
6499
6500 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6501 PyObject *resultobj;
6502 wxCaret *arg1 = (wxCaret *) 0 ;
6503 PyObject * obj0 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "self", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6510 if (SWIG_arg_fail(1)) SWIG_fail;
6511 {
6512 PyThreadState* __tstate = wxPyBeginAllowThreads();
6513 wxCaret_Destroy(arg1);
6514
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 Py_INCREF(Py_None); resultobj = Py_None;
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6526 PyObject *resultobj;
6527 wxCaret *arg1 = (wxCaret *) 0 ;
6528 bool result;
6529 PyObject * obj0 = 0 ;
6530 char *kwnames[] = {
6531 (char *) "self", NULL
6532 };
6533
6534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6536 if (SWIG_arg_fail(1)) SWIG_fail;
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (bool)(arg1)->IsOk();
6540
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 {
6545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6546 }
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj;
6555 wxCaret *arg1 = (wxCaret *) 0 ;
6556 bool result;
6557 PyObject * obj0 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self", NULL
6560 };
6561
6562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6564 if (SWIG_arg_fail(1)) SWIG_fail;
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 result = (bool)(arg1)->IsVisible();
6568
6569 wxPyEndAllowThreads(__tstate);
6570 if (PyErr_Occurred()) SWIG_fail;
6571 }
6572 {
6573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6574 }
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6582 PyObject *resultobj;
6583 wxCaret *arg1 = (wxCaret *) 0 ;
6584 wxPoint result;
6585 PyObject * obj0 = 0 ;
6586 char *kwnames[] = {
6587 (char *) "self", NULL
6588 };
6589
6590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6592 if (SWIG_arg_fail(1)) SWIG_fail;
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 result = (arg1)->GetPosition();
6596
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 {
6601 wxPoint * resultptr;
6602 resultptr = new wxPoint((wxPoint &)(result));
6603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6604 }
6605 return resultobj;
6606 fail:
6607 return NULL;
6608 }
6609
6610
6611 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6612 PyObject *resultobj;
6613 wxCaret *arg1 = (wxCaret *) 0 ;
6614 int *arg2 = (int *) 0 ;
6615 int *arg3 = (int *) 0 ;
6616 int temp2 ;
6617 int res2 = 0 ;
6618 int temp3 ;
6619 int res3 = 0 ;
6620 PyObject * obj0 = 0 ;
6621 char *kwnames[] = {
6622 (char *) "self", NULL
6623 };
6624
6625 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6626 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
6632 (arg1)->GetPosition(arg2,arg3);
6633
6634 wxPyEndAllowThreads(__tstate);
6635 if (PyErr_Occurred()) SWIG_fail;
6636 }
6637 Py_INCREF(Py_None); resultobj = Py_None;
6638 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6639 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6640 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6641 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj;
6650 wxCaret *arg1 = (wxCaret *) 0 ;
6651 wxSize result;
6652 PyObject * obj0 = 0 ;
6653 char *kwnames[] = {
6654 (char *) "self", NULL
6655 };
6656
6657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6659 if (SWIG_arg_fail(1)) SWIG_fail;
6660 {
6661 PyThreadState* __tstate = wxPyBeginAllowThreads();
6662 result = (arg1)->GetSize();
6663
6664 wxPyEndAllowThreads(__tstate);
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 {
6668 wxSize * resultptr;
6669 resultptr = new wxSize((wxSize &)(result));
6670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6671 }
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxCaret *arg1 = (wxCaret *) 0 ;
6681 int *arg2 = (int *) 0 ;
6682 int *arg3 = (int *) 0 ;
6683 int temp2 ;
6684 int res2 = 0 ;
6685 int temp3 ;
6686 int res3 = 0 ;
6687 PyObject * obj0 = 0 ;
6688 char *kwnames[] = {
6689 (char *) "self", NULL
6690 };
6691
6692 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6693 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6696 if (SWIG_arg_fail(1)) SWIG_fail;
6697 {
6698 PyThreadState* __tstate = wxPyBeginAllowThreads();
6699 (arg1)->GetSize(arg2,arg3);
6700
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 Py_INCREF(Py_None); resultobj = Py_None;
6705 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6706 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6707 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6708 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj;
6717 wxCaret *arg1 = (wxCaret *) 0 ;
6718 wxWindow *result;
6719 PyObject * obj0 = 0 ;
6720 char *kwnames[] = {
6721 (char *) "self", NULL
6722 };
6723
6724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6726 if (SWIG_arg_fail(1)) SWIG_fail;
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = (wxWindow *)(arg1)->GetWindow();
6730
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 {
6735 resultobj = wxPyMake_wxObject(result, 0);
6736 }
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 wxCaret *arg1 = (wxCaret *) 0 ;
6746 int arg2 ;
6747 int arg3 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 PyObject * obj2 = 0 ;
6751 char *kwnames[] = {
6752 (char *) "self",(char *) "x",(char *) "y", NULL
6753 };
6754
6755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6757 if (SWIG_arg_fail(1)) SWIG_fail;
6758 {
6759 arg2 = (int)(SWIG_As_int(obj1));
6760 if (SWIG_arg_fail(2)) SWIG_fail;
6761 }
6762 {
6763 arg3 = (int)(SWIG_As_int(obj2));
6764 if (SWIG_arg_fail(3)) SWIG_fail;
6765 }
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 (arg1)->Move(arg2,arg3);
6769
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 Py_INCREF(Py_None); resultobj = Py_None;
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6781 PyObject *resultobj;
6782 wxCaret *arg1 = (wxCaret *) 0 ;
6783 wxPoint *arg2 = 0 ;
6784 wxPoint temp2 ;
6785 PyObject * obj0 = 0 ;
6786 PyObject * obj1 = 0 ;
6787 char *kwnames[] = {
6788 (char *) "self",(char *) "pt", NULL
6789 };
6790
6791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6793 if (SWIG_arg_fail(1)) SWIG_fail;
6794 {
6795 arg2 = &temp2;
6796 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6797 }
6798 {
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 (arg1)->Move((wxPoint const &)*arg2);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 Py_INCREF(Py_None); resultobj = Py_None;
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6813 PyObject *resultobj;
6814 wxCaret *arg1 = (wxCaret *) 0 ;
6815 int arg2 ;
6816 int arg3 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 PyObject * obj2 = 0 ;
6820 char *kwnames[] = {
6821 (char *) "self",(char *) "width",(char *) "height", NULL
6822 };
6823
6824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6826 if (SWIG_arg_fail(1)) SWIG_fail;
6827 {
6828 arg2 = (int)(SWIG_As_int(obj1));
6829 if (SWIG_arg_fail(2)) SWIG_fail;
6830 }
6831 {
6832 arg3 = (int)(SWIG_As_int(obj2));
6833 if (SWIG_arg_fail(3)) SWIG_fail;
6834 }
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 (arg1)->SetSize(arg2,arg3);
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 Py_INCREF(Py_None); resultobj = Py_None;
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj;
6851 wxCaret *arg1 = (wxCaret *) 0 ;
6852 wxSize *arg2 = 0 ;
6853 wxSize temp2 ;
6854 PyObject * obj0 = 0 ;
6855 PyObject * obj1 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self",(char *) "size", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 arg2 = &temp2;
6865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6866 }
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 (arg1)->SetSize((wxSize const &)*arg2);
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 Py_INCREF(Py_None); resultobj = Py_None;
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj;
6883 wxCaret *arg1 = (wxCaret *) 0 ;
6884 int arg2 = (int) true ;
6885 PyObject * obj0 = 0 ;
6886 PyObject * obj1 = 0 ;
6887 char *kwnames[] = {
6888 (char *) "self",(char *) "show", NULL
6889 };
6890
6891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6893 if (SWIG_arg_fail(1)) SWIG_fail;
6894 if (obj1) {
6895 {
6896 arg2 = (int)(SWIG_As_int(obj1));
6897 if (SWIG_arg_fail(2)) SWIG_fail;
6898 }
6899 }
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 (arg1)->Show(arg2);
6903
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 Py_INCREF(Py_None); resultobj = Py_None;
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj;
6916 wxCaret *arg1 = (wxCaret *) 0 ;
6917 PyObject * obj0 = 0 ;
6918 char *kwnames[] = {
6919 (char *) "self", NULL
6920 };
6921
6922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6924 if (SWIG_arg_fail(1)) SWIG_fail;
6925 {
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 (arg1)->Hide();
6928
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 Py_INCREF(Py_None); resultobj = Py_None;
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj;
6941 int result;
6942 char *kwnames[] = {
6943 NULL
6944 };
6945
6946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (int)wxCaret::GetBlinkTime();
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 resultobj = SWIG_From_int((int)(result));
6956 }
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 int arg1 ;
6966 PyObject * obj0 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "milliseconds", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6972 {
6973 arg1 = (int)(SWIG_As_int(obj0));
6974 if (SWIG_arg_fail(1)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 wxCaret::SetBlinkTime(arg1);
6979
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 Py_INCREF(Py_None); resultobj = Py_None;
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6991 PyObject *obj;
6992 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6993 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6994 Py_INCREF(obj);
6995 return Py_BuildValue((char *)"");
6996 }
6997 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6998 PyObject *resultobj;
6999 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7000 wxBusyCursor *result;
7001 PyObject * obj0 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "cursor", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7007 if (obj0) {
7008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7009 if (SWIG_arg_fail(1)) SWIG_fail;
7010 }
7011 {
7012 if (!wxPyCheckForApp()) SWIG_fail;
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7015
7016 wxPyEndAllowThreads(__tstate);
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7020 return resultobj;
7021 fail:
7022 return NULL;
7023 }
7024
7025
7026 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7027 PyObject *resultobj;
7028 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7029 PyObject * obj0 = 0 ;
7030 char *kwnames[] = {
7031 (char *) "self", NULL
7032 };
7033
7034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7036 if (SWIG_arg_fail(1)) SWIG_fail;
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 delete arg1;
7040
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 Py_INCREF(Py_None); resultobj = Py_None;
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7052 PyObject *obj;
7053 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7054 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7055 Py_INCREF(obj);
7056 return Py_BuildValue((char *)"");
7057 }
7058 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7059 PyObject *resultobj;
7060 wxWindow *arg1 = (wxWindow *) NULL ;
7061 wxWindowDisabler *result;
7062 PyObject * obj0 = 0 ;
7063 char *kwnames[] = {
7064 (char *) "winToSkip", NULL
7065 };
7066
7067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7068 if (obj0) {
7069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7070 if (SWIG_arg_fail(1)) SWIG_fail;
7071 }
7072 {
7073 if (!wxPyCheckForApp()) SWIG_fail;
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7076
7077 wxPyEndAllowThreads(__tstate);
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7088 PyObject *resultobj;
7089 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7090 PyObject * obj0 = 0 ;
7091 char *kwnames[] = {
7092 (char *) "self", NULL
7093 };
7094
7095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7097 if (SWIG_arg_fail(1)) SWIG_fail;
7098 {
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 delete arg1;
7101
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 Py_INCREF(Py_None); resultobj = Py_None;
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7113 PyObject *obj;
7114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7115 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7116 Py_INCREF(obj);
7117 return Py_BuildValue((char *)"");
7118 }
7119 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7120 PyObject *resultobj;
7121 wxString *arg1 = 0 ;
7122 wxBusyInfo *result;
7123 bool temp1 = false ;
7124 PyObject * obj0 = 0 ;
7125 char *kwnames[] = {
7126 (char *) "message", NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7130 {
7131 arg1 = wxString_in_helper(obj0);
7132 if (arg1 == NULL) SWIG_fail;
7133 temp1 = true;
7134 }
7135 {
7136 if (!wxPyCheckForApp()) SWIG_fail;
7137 PyThreadState* __tstate = wxPyBeginAllowThreads();
7138 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7139
7140 wxPyEndAllowThreads(__tstate);
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7144 {
7145 if (temp1)
7146 delete arg1;
7147 }
7148 return resultobj;
7149 fail:
7150 {
7151 if (temp1)
7152 delete arg1;
7153 }
7154 return NULL;
7155 }
7156
7157
7158 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7159 PyObject *resultobj;
7160 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7161 PyObject * obj0 = 0 ;
7162 char *kwnames[] = {
7163 (char *) "self", NULL
7164 };
7165
7166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7168 if (SWIG_arg_fail(1)) SWIG_fail;
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 delete arg1;
7172
7173 wxPyEndAllowThreads(__tstate);
7174 if (PyErr_Occurred()) SWIG_fail;
7175 }
7176 Py_INCREF(Py_None); resultobj = Py_None;
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7184 PyObject *obj;
7185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7186 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7187 Py_INCREF(obj);
7188 return Py_BuildValue((char *)"");
7189 }
7190 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7191 PyObject *resultobj;
7192 wxStopWatch *result;
7193 char *kwnames[] = {
7194 NULL
7195 };
7196
7197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7198 {
7199 PyThreadState* __tstate = wxPyBeginAllowThreads();
7200 result = (wxStopWatch *)new wxStopWatch();
7201
7202 wxPyEndAllowThreads(__tstate);
7203 if (PyErr_Occurred()) SWIG_fail;
7204 }
7205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7206 return resultobj;
7207 fail:
7208 return NULL;
7209 }
7210
7211
7212 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7213 PyObject *resultobj;
7214 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7215 long arg2 = (long) 0 ;
7216 PyObject * obj0 = 0 ;
7217 PyObject * obj1 = 0 ;
7218 char *kwnames[] = {
7219 (char *) "self",(char *) "t0", NULL
7220 };
7221
7222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7224 if (SWIG_arg_fail(1)) SWIG_fail;
7225 if (obj1) {
7226 {
7227 arg2 = (long)(SWIG_As_long(obj1));
7228 if (SWIG_arg_fail(2)) SWIG_fail;
7229 }
7230 }
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 (arg1)->Start(arg2);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 Py_INCREF(Py_None); resultobj = Py_None;
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj;
7247 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 (arg1)->Pause();
7259
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 Py_INCREF(Py_None); resultobj = Py_None;
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj;
7272 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7273 PyObject * obj0 = 0 ;
7274 char *kwnames[] = {
7275 (char *) "self", NULL
7276 };
7277
7278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(1)) SWIG_fail;
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 (arg1)->Resume();
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 Py_INCREF(Py_None); resultobj = Py_None;
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7298 long result;
7299 PyObject * obj0 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "self", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7306 if (SWIG_arg_fail(1)) SWIG_fail;
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 result = (long)((wxStopWatch const *)arg1)->Time();
7310
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 {
7315 resultobj = SWIG_From_long((long)(result));
7316 }
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7324 PyObject *obj;
7325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7326 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7327 Py_INCREF(obj);
7328 return Py_BuildValue((char *)"");
7329 }
7330 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj;
7332 int arg1 = (int) 9 ;
7333 int arg2 = (int) wxID_FILE1 ;
7334 wxFileHistory *result;
7335 PyObject * obj0 = 0 ;
7336 PyObject * obj1 = 0 ;
7337 char *kwnames[] = {
7338 (char *) "maxFiles",(char *) "idBase", NULL
7339 };
7340
7341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7342 if (obj0) {
7343 {
7344 arg1 = (int)(SWIG_As_int(obj0));
7345 if (SWIG_arg_fail(1)) SWIG_fail;
7346 }
7347 }
7348 if (obj1) {
7349 {
7350 arg2 = (int)(SWIG_As_int(obj1));
7351 if (SWIG_arg_fail(2)) SWIG_fail;
7352 }
7353 }
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7357
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj;
7370 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7371 PyObject * obj0 = 0 ;
7372 char *kwnames[] = {
7373 (char *) "self", NULL
7374 };
7375
7376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7378 if (SWIG_arg_fail(1)) SWIG_fail;
7379 {
7380 PyThreadState* __tstate = wxPyBeginAllowThreads();
7381 delete arg1;
7382
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 Py_INCREF(Py_None); resultobj = Py_None;
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj;
7395 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7396 wxString *arg2 = 0 ;
7397 bool temp2 = false ;
7398 PyObject * obj0 = 0 ;
7399 PyObject * obj1 = 0 ;
7400 char *kwnames[] = {
7401 (char *) "self",(char *) "file", NULL
7402 };
7403
7404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(1)) SWIG_fail;
7407 {
7408 arg2 = wxString_in_helper(obj1);
7409 if (arg2 == NULL) SWIG_fail;
7410 temp2 = true;
7411 }
7412 {
7413 PyThreadState* __tstate = wxPyBeginAllowThreads();
7414 (arg1)->AddFileToHistory((wxString const &)*arg2);
7415
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 Py_INCREF(Py_None); resultobj = Py_None;
7420 {
7421 if (temp2)
7422 delete arg2;
7423 }
7424 return resultobj;
7425 fail:
7426 {
7427 if (temp2)
7428 delete arg2;
7429 }
7430 return NULL;
7431 }
7432
7433
7434 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7435 PyObject *resultobj;
7436 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7437 int arg2 ;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 char *kwnames[] = {
7441 (char *) "self",(char *) "i", NULL
7442 };
7443
7444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7446 if (SWIG_arg_fail(1)) SWIG_fail;
7447 {
7448 arg2 = (int)(SWIG_As_int(obj1));
7449 if (SWIG_arg_fail(2)) SWIG_fail;
7450 }
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 (arg1)->RemoveFileFromHistory(arg2);
7454
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 Py_INCREF(Py_None); resultobj = Py_None;
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj;
7467 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7468 int result;
7469 PyObject * obj0 = 0 ;
7470 char *kwnames[] = {
7471 (char *) "self", NULL
7472 };
7473
7474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7476 if (SWIG_arg_fail(1)) SWIG_fail;
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7480
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = SWIG_From_int((int)(result));
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj;
7495 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7496 wxMenu *arg2 = (wxMenu *) 0 ;
7497 PyObject * obj0 = 0 ;
7498 PyObject * obj1 = 0 ;
7499 char *kwnames[] = {
7500 (char *) "self",(char *) "menu", NULL
7501 };
7502
7503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7505 if (SWIG_arg_fail(1)) SWIG_fail;
7506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7507 if (SWIG_arg_fail(2)) SWIG_fail;
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 (arg1)->UseMenu(arg2);
7511
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 Py_INCREF(Py_None); resultobj = Py_None;
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj;
7524 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7525 wxMenu *arg2 = (wxMenu *) 0 ;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "self",(char *) "menu", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(1)) SWIG_fail;
7535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7536 if (SWIG_arg_fail(2)) SWIG_fail;
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 (arg1)->RemoveMenu(arg2);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 Py_INCREF(Py_None); resultobj = Py_None;
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj;
7553 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7554 wxConfigBase *arg2 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 char *kwnames[] = {
7558 (char *) "self",(char *) "config", NULL
7559 };
7560
7561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7563 if (SWIG_arg_fail(1)) SWIG_fail;
7564 {
7565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7566 if (SWIG_arg_fail(2)) SWIG_fail;
7567 if (arg2 == NULL) {
7568 SWIG_null_ref("wxConfigBase");
7569 }
7570 if (SWIG_arg_fail(2)) SWIG_fail;
7571 }
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 (arg1)->Load(*arg2);
7575
7576 wxPyEndAllowThreads(__tstate);
7577 if (PyErr_Occurred()) SWIG_fail;
7578 }
7579 Py_INCREF(Py_None); resultobj = Py_None;
7580 return resultobj;
7581 fail:
7582 return NULL;
7583 }
7584
7585
7586 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7587 PyObject *resultobj;
7588 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7589 wxConfigBase *arg2 = 0 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 char *kwnames[] = {
7593 (char *) "self",(char *) "config", NULL
7594 };
7595
7596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7598 if (SWIG_arg_fail(1)) SWIG_fail;
7599 {
7600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(2)) SWIG_fail;
7602 if (arg2 == NULL) {
7603 SWIG_null_ref("wxConfigBase");
7604 }
7605 if (SWIG_arg_fail(2)) SWIG_fail;
7606 }
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 (arg1)->Save(*arg2);
7610
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 Py_INCREF(Py_None); resultobj = Py_None;
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj;
7623 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7624 PyObject * obj0 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 PyThreadState* __tstate = wxPyBeginAllowThreads();
7634 (arg1)->AddFilesToMenu();
7635
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 Py_INCREF(Py_None); resultobj = Py_None;
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj;
7648 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7649 wxMenu *arg2 = (wxMenu *) 0 ;
7650 PyObject * obj0 = 0 ;
7651 PyObject * obj1 = 0 ;
7652 char *kwnames[] = {
7653 (char *) "self",(char *) "menu", NULL
7654 };
7655
7656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7658 if (SWIG_arg_fail(1)) SWIG_fail;
7659 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7660 if (SWIG_arg_fail(2)) SWIG_fail;
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 (arg1)->AddFilesToMenu(arg2);
7664
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 Py_INCREF(Py_None); resultobj = Py_None;
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7676 PyObject *resultobj;
7677 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7678 int arg2 ;
7679 wxString result;
7680 PyObject * obj0 = 0 ;
7681 PyObject * obj1 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "self",(char *) "i", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(1)) SWIG_fail;
7689 {
7690 arg2 = (int)(SWIG_As_int(obj1));
7691 if (SWIG_arg_fail(2)) SWIG_fail;
7692 }
7693 {
7694 PyThreadState* __tstate = wxPyBeginAllowThreads();
7695 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7696
7697 wxPyEndAllowThreads(__tstate);
7698 if (PyErr_Occurred()) SWIG_fail;
7699 }
7700 {
7701 #if wxUSE_UNICODE
7702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7703 #else
7704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7705 #endif
7706 }
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj;
7715 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7716 int result;
7717 PyObject * obj0 = 0 ;
7718 char *kwnames[] = {
7719 (char *) "self", NULL
7720 };
7721
7722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7724 if (SWIG_arg_fail(1)) SWIG_fail;
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 result = (int)((wxFileHistory const *)arg1)->GetCount();
7728
7729 wxPyEndAllowThreads(__tstate);
7730 if (PyErr_Occurred()) SWIG_fail;
7731 }
7732 {
7733 resultobj = SWIG_From_int((int)(result));
7734 }
7735 return resultobj;
7736 fail:
7737 return NULL;
7738 }
7739
7740
7741 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7742 PyObject *obj;
7743 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7744 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7745 Py_INCREF(obj);
7746 return Py_BuildValue((char *)"");
7747 }
7748 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7749 PyObject *resultobj;
7750 wxString *arg1 = 0 ;
7751 wxString const &arg2_defvalue = wxPyEmptyString ;
7752 wxString *arg2 = (wxString *) &arg2_defvalue ;
7753 wxSingleInstanceChecker *result;
7754 bool temp1 = false ;
7755 bool temp2 = false ;
7756 PyObject * obj0 = 0 ;
7757 PyObject * obj1 = 0 ;
7758 char *kwnames[] = {
7759 (char *) "name",(char *) "path", NULL
7760 };
7761
7762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7763 {
7764 arg1 = wxString_in_helper(obj0);
7765 if (arg1 == NULL) SWIG_fail;
7766 temp1 = true;
7767 }
7768 if (obj1) {
7769 {
7770 arg2 = wxString_in_helper(obj1);
7771 if (arg2 == NULL) SWIG_fail;
7772 temp2 = true;
7773 }
7774 }
7775 {
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7778
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7783 {
7784 if (temp1)
7785 delete arg1;
7786 }
7787 {
7788 if (temp2)
7789 delete arg2;
7790 }
7791 return resultobj;
7792 fail:
7793 {
7794 if (temp1)
7795 delete arg1;
7796 }
7797 {
7798 if (temp2)
7799 delete arg2;
7800 }
7801 return NULL;
7802 }
7803
7804
7805 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7806 PyObject *resultobj;
7807 wxSingleInstanceChecker *result;
7808 char *kwnames[] = {
7809 NULL
7810 };
7811
7812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7816
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7821 return resultobj;
7822 fail:
7823 return NULL;
7824 }
7825
7826
7827 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj;
7829 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7830 PyObject * obj0 = 0 ;
7831 char *kwnames[] = {
7832 (char *) "self", NULL
7833 };
7834
7835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7837 if (SWIG_arg_fail(1)) SWIG_fail;
7838 {
7839 PyThreadState* __tstate = wxPyBeginAllowThreads();
7840 delete arg1;
7841
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 Py_INCREF(Py_None); resultobj = Py_None;
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj;
7854 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7855 wxString *arg2 = 0 ;
7856 wxString const &arg3_defvalue = wxPyEmptyString ;
7857 wxString *arg3 = (wxString *) &arg3_defvalue ;
7858 bool result;
7859 bool temp2 = false ;
7860 bool temp3 = false ;
7861 PyObject * obj0 = 0 ;
7862 PyObject * obj1 = 0 ;
7863 PyObject * obj2 = 0 ;
7864 char *kwnames[] = {
7865 (char *) "self",(char *) "name",(char *) "path", NULL
7866 };
7867
7868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7870 if (SWIG_arg_fail(1)) SWIG_fail;
7871 {
7872 arg2 = wxString_in_helper(obj1);
7873 if (arg2 == NULL) SWIG_fail;
7874 temp2 = true;
7875 }
7876 if (obj2) {
7877 {
7878 arg3 = wxString_in_helper(obj2);
7879 if (arg3 == NULL) SWIG_fail;
7880 temp3 = true;
7881 }
7882 }
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7886
7887 wxPyEndAllowThreads(__tstate);
7888 if (PyErr_Occurred()) SWIG_fail;
7889 }
7890 {
7891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7892 }
7893 {
7894 if (temp2)
7895 delete arg2;
7896 }
7897 {
7898 if (temp3)
7899 delete arg3;
7900 }
7901 return resultobj;
7902 fail:
7903 {
7904 if (temp2)
7905 delete arg2;
7906 }
7907 {
7908 if (temp3)
7909 delete arg3;
7910 }
7911 return NULL;
7912 }
7913
7914
7915 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7916 PyObject *resultobj;
7917 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7918 bool result;
7919 PyObject * obj0 = 0 ;
7920 char *kwnames[] = {
7921 (char *) "self", NULL
7922 };
7923
7924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7926 if (SWIG_arg_fail(1)) SWIG_fail;
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7930
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 {
7935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7936 }
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7944 PyObject *obj;
7945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7946 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7947 Py_INCREF(obj);
7948 return Py_BuildValue((char *)"");
7949 }
7950 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7951 PyObject *resultobj;
7952 wxWindow *arg1 = (wxWindow *) 0 ;
7953 wxDC *arg2 = 0 ;
7954 bool result;
7955 PyObject * obj0 = 0 ;
7956 PyObject * obj1 = 0 ;
7957 char *kwnames[] = {
7958 (char *) "window",(char *) "dc", NULL
7959 };
7960
7961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7963 if (SWIG_arg_fail(1)) SWIG_fail;
7964 {
7965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7966 if (SWIG_arg_fail(2)) SWIG_fail;
7967 if (arg2 == NULL) {
7968 SWIG_null_ref("wxDC");
7969 }
7970 if (SWIG_arg_fail(2)) SWIG_fail;
7971 }
7972 {
7973 PyThreadState* __tstate = wxPyBeginAllowThreads();
7974 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7975
7976 wxPyEndAllowThreads(__tstate);
7977 if (PyErr_Occurred()) SWIG_fail;
7978 }
7979 {
7980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7981 }
7982 return resultobj;
7983 fail:
7984 return NULL;
7985 }
7986
7987
7988 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7989 PyObject *resultobj;
7990 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7991 PyObject * obj0 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "self", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7998 if (SWIG_arg_fail(1)) SWIG_fail;
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 delete arg1;
8002
8003 wxPyEndAllowThreads(__tstate);
8004 if (PyErr_Occurred()) SWIG_fail;
8005 }
8006 Py_INCREF(Py_None); resultobj = Py_None;
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8016 wxString result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (arg1)->GetTip();
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 {
8033 #if wxUSE_UNICODE
8034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8035 #else
8036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8037 #endif
8038 }
8039 return resultobj;
8040 fail:
8041 return NULL;
8042 }
8043
8044
8045 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8046 PyObject *resultobj;
8047 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8048 size_t result;
8049 PyObject * obj0 = 0 ;
8050 char *kwnames[] = {
8051 (char *) "self", NULL
8052 };
8053
8054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8056 if (SWIG_arg_fail(1)) SWIG_fail;
8057 {
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 result = (size_t)(arg1)->GetCurrentTip();
8060
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 {
8065 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
8066 }
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj;
8075 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8076 wxString *arg2 = 0 ;
8077 wxString result;
8078 bool temp2 = false ;
8079 PyObject * obj0 = 0 ;
8080 PyObject * obj1 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self",(char *) "tip", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 {
8089 arg2 = wxString_in_helper(obj1);
8090 if (arg2 == NULL) SWIG_fail;
8091 temp2 = true;
8092 }
8093 {
8094 PyThreadState* __tstate = wxPyBeginAllowThreads();
8095 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8096
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 {
8101 #if wxUSE_UNICODE
8102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8103 #else
8104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8105 #endif
8106 }
8107 {
8108 if (temp2)
8109 delete arg2;
8110 }
8111 return resultobj;
8112 fail:
8113 {
8114 if (temp2)
8115 delete arg2;
8116 }
8117 return NULL;
8118 }
8119
8120
8121 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8122 PyObject *obj;
8123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8124 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8125 Py_INCREF(obj);
8126 return Py_BuildValue((char *)"");
8127 }
8128 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj;
8130 size_t arg1 ;
8131 wxPyTipProvider *result;
8132 PyObject * obj0 = 0 ;
8133 char *kwnames[] = {
8134 (char *) "currentTip", NULL
8135 };
8136
8137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8138 {
8139 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8140 if (SWIG_arg_fail(1)) SWIG_fail;
8141 }
8142 {
8143 PyThreadState* __tstate = wxPyBeginAllowThreads();
8144 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8145
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8159 PyObject *arg2 = (PyObject *) 0 ;
8160 PyObject *arg3 = (PyObject *) 0 ;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 PyObject * obj2 = 0 ;
8164 char *kwnames[] = {
8165 (char *) "self",(char *) "self",(char *) "_class", NULL
8166 };
8167
8168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8170 if (SWIG_arg_fail(1)) SWIG_fail;
8171 arg2 = obj1;
8172 arg3 = obj2;
8173 {
8174 PyThreadState* __tstate = wxPyBeginAllowThreads();
8175 (arg1)->_setCallbackInfo(arg2,arg3);
8176
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 Py_INCREF(Py_None); resultobj = Py_None;
8181 return resultobj;
8182 fail:
8183 return NULL;
8184 }
8185
8186
8187 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8188 PyObject *obj;
8189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8190 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8191 Py_INCREF(obj);
8192 return Py_BuildValue((char *)"");
8193 }
8194 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj;
8196 wxWindow *arg1 = (wxWindow *) 0 ;
8197 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8198 bool arg3 = (bool) true ;
8199 bool result;
8200 PyObject * obj0 = 0 ;
8201 PyObject * obj1 = 0 ;
8202 PyObject * obj2 = 0 ;
8203 char *kwnames[] = {
8204 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8205 };
8206
8207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(1)) SWIG_fail;
8210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8211 if (SWIG_arg_fail(2)) SWIG_fail;
8212 if (obj2) {
8213 {
8214 arg3 = (bool)(SWIG_As_bool(obj2));
8215 if (SWIG_arg_fail(3)) SWIG_fail;
8216 }
8217 }
8218 {
8219 if (!wxPyCheckForApp()) SWIG_fail;
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 result = (bool)wxShowTip(arg1,arg2,arg3);
8222
8223 wxPyEndAllowThreads(__tstate);
8224 if (PyErr_Occurred()) SWIG_fail;
8225 }
8226 {
8227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8228 }
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj;
8237 wxString *arg1 = 0 ;
8238 size_t arg2 ;
8239 wxTipProvider *result;
8240 bool temp1 = false ;
8241 PyObject * obj0 = 0 ;
8242 PyObject * obj1 = 0 ;
8243 char *kwnames[] = {
8244 (char *) "filename",(char *) "currentTip", NULL
8245 };
8246
8247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8248 {
8249 arg1 = wxString_in_helper(obj0);
8250 if (arg1 == NULL) SWIG_fail;
8251 temp1 = true;
8252 }
8253 {
8254 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8255 if (SWIG_arg_fail(2)) SWIG_fail;
8256 }
8257 {
8258 if (!wxPyCheckForApp()) SWIG_fail;
8259 PyThreadState* __tstate = wxPyBeginAllowThreads();
8260 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8261
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8266 {
8267 if (temp1)
8268 delete arg1;
8269 }
8270 return resultobj;
8271 fail:
8272 {
8273 if (temp1)
8274 delete arg1;
8275 }
8276 return NULL;
8277 }
8278
8279
8280 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj;
8282 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8283 int arg2 = (int) -1 ;
8284 wxPyTimer *result;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "owner",(char *) "id", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8292 if (obj0) {
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 }
8296 if (obj1) {
8297 {
8298 arg2 = (int)(SWIG_As_int(obj1));
8299 if (SWIG_arg_fail(2)) SWIG_fail;
8300 }
8301 }
8302 {
8303 if (!wxPyCheckForApp()) SWIG_fail;
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8306
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj;
8319 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8320 PyObject * obj0 = 0 ;
8321 char *kwnames[] = {
8322 (char *) "self", NULL
8323 };
8324
8325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8327 if (SWIG_arg_fail(1)) SWIG_fail;
8328 {
8329 PyThreadState* __tstate = wxPyBeginAllowThreads();
8330 delete arg1;
8331
8332 wxPyEndAllowThreads(__tstate);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 Py_INCREF(Py_None); resultobj = Py_None;
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj;
8344 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8345 PyObject *arg2 = (PyObject *) 0 ;
8346 PyObject *arg3 = (PyObject *) 0 ;
8347 int arg4 = (int) 1 ;
8348 PyObject * obj0 = 0 ;
8349 PyObject * obj1 = 0 ;
8350 PyObject * obj2 = 0 ;
8351 PyObject * obj3 = 0 ;
8352 char *kwnames[] = {
8353 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8354 };
8355
8356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(1)) SWIG_fail;
8359 arg2 = obj1;
8360 arg3 = obj2;
8361 if (obj3) {
8362 {
8363 arg4 = (int)(SWIG_As_int(obj3));
8364 if (SWIG_arg_fail(4)) SWIG_fail;
8365 }
8366 }
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8370
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 Py_INCREF(Py_None); resultobj = Py_None;
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8384 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8385 int arg3 = (int) -1 ;
8386 PyObject * obj0 = 0 ;
8387 PyObject * obj1 = 0 ;
8388 PyObject * obj2 = 0 ;
8389 char *kwnames[] = {
8390 (char *) "self",(char *) "owner",(char *) "id", NULL
8391 };
8392
8393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8395 if (SWIG_arg_fail(1)) SWIG_fail;
8396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8397 if (SWIG_arg_fail(2)) SWIG_fail;
8398 if (obj2) {
8399 {
8400 arg3 = (int)(SWIG_As_int(obj2));
8401 if (SWIG_arg_fail(3)) SWIG_fail;
8402 }
8403 }
8404 {
8405 PyThreadState* __tstate = wxPyBeginAllowThreads();
8406 (arg1)->SetOwner(arg2,arg3);
8407
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 Py_INCREF(Py_None); resultobj = Py_None;
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8419 PyObject *resultobj;
8420 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8421 wxEvtHandler *result;
8422 PyObject * obj0 = 0 ;
8423 char *kwnames[] = {
8424 (char *) "self", NULL
8425 };
8426
8427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8429 if (SWIG_arg_fail(1)) SWIG_fail;
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 result = (wxEvtHandler *)(arg1)->GetOwner();
8433
8434 wxPyEndAllowThreads(__tstate);
8435 if (PyErr_Occurred()) SWIG_fail;
8436 }
8437 {
8438 resultobj = wxPyMake_wxObject(result, 0);
8439 }
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8447 PyObject *resultobj;
8448 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8449 int arg2 = (int) -1 ;
8450 bool arg3 = (bool) false ;
8451 bool result;
8452 PyObject * obj0 = 0 ;
8453 PyObject * obj1 = 0 ;
8454 PyObject * obj2 = 0 ;
8455 char *kwnames[] = {
8456 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8457 };
8458
8459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8461 if (SWIG_arg_fail(1)) SWIG_fail;
8462 if (obj1) {
8463 {
8464 arg2 = (int)(SWIG_As_int(obj1));
8465 if (SWIG_arg_fail(2)) SWIG_fail;
8466 }
8467 }
8468 if (obj2) {
8469 {
8470 arg3 = (bool)(SWIG_As_bool(obj2));
8471 if (SWIG_arg_fail(3)) SWIG_fail;
8472 }
8473 }
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (bool)(arg1)->Start(arg2,arg3);
8477
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 {
8482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8483 }
8484 return resultobj;
8485 fail:
8486 return NULL;
8487 }
8488
8489
8490 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8491 PyObject *resultobj;
8492 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8493 PyObject * obj0 = 0 ;
8494 char *kwnames[] = {
8495 (char *) "self", NULL
8496 };
8497
8498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8500 if (SWIG_arg_fail(1)) SWIG_fail;
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 (arg1)->Stop();
8504
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 Py_INCREF(Py_None); resultobj = Py_None;
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj;
8517 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8518 bool result;
8519 PyObject * obj0 = 0 ;
8520 char *kwnames[] = {
8521 (char *) "self", NULL
8522 };
8523
8524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8526 if (SWIG_arg_fail(1)) SWIG_fail;
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8530
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8536 }
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj;
8545 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8546 int result;
8547 PyObject * obj0 = 0 ;
8548 char *kwnames[] = {
8549 (char *) "self", NULL
8550 };
8551
8552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8554 if (SWIG_arg_fail(1)) SWIG_fail;
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8558
8559 wxPyEndAllowThreads(__tstate);
8560 if (PyErr_Occurred()) SWIG_fail;
8561 }
8562 {
8563 resultobj = SWIG_From_int((int)(result));
8564 }
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8572 PyObject *resultobj;
8573 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8574 bool result;
8575 PyObject * obj0 = 0 ;
8576 char *kwnames[] = {
8577 (char *) "self", NULL
8578 };
8579
8580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8586
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 {
8591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8592 }
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj;
8601 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8602 int result;
8603 PyObject * obj0 = 0 ;
8604 char *kwnames[] = {
8605 (char *) "self", NULL
8606 };
8607
8608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8610 if (SWIG_arg_fail(1)) SWIG_fail;
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 result = (int)((wxPyTimer const *)arg1)->GetId();
8614
8615 wxPyEndAllowThreads(__tstate);
8616 if (PyErr_Occurred()) SWIG_fail;
8617 }
8618 {
8619 resultobj = SWIG_From_int((int)(result));
8620 }
8621 return resultobj;
8622 fail:
8623 return NULL;
8624 }
8625
8626
8627 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8628 PyObject *obj;
8629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8630 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8631 Py_INCREF(obj);
8632 return Py_BuildValue((char *)"");
8633 }
8634 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj;
8636 int arg1 = (int) 0 ;
8637 int arg2 = (int) 0 ;
8638 wxTimerEvent *result;
8639 PyObject * obj0 = 0 ;
8640 PyObject * obj1 = 0 ;
8641 char *kwnames[] = {
8642 (char *) "timerid",(char *) "interval", NULL
8643 };
8644
8645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8646 if (obj0) {
8647 {
8648 arg1 = (int)(SWIG_As_int(obj0));
8649 if (SWIG_arg_fail(1)) SWIG_fail;
8650 }
8651 }
8652 if (obj1) {
8653 {
8654 arg2 = (int)(SWIG_As_int(obj1));
8655 if (SWIG_arg_fail(2)) SWIG_fail;
8656 }
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8661
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj;
8674 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8675 int result;
8676 PyObject * obj0 = 0 ;
8677 char *kwnames[] = {
8678 (char *) "self", NULL
8679 };
8680
8681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8683 if (SWIG_arg_fail(1)) SWIG_fail;
8684 {
8685 PyThreadState* __tstate = wxPyBeginAllowThreads();
8686 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8687
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 {
8692 resultobj = SWIG_From_int((int)(result));
8693 }
8694 return resultobj;
8695 fail:
8696 return NULL;
8697 }
8698
8699
8700 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8701 PyObject *obj;
8702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8703 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8704 Py_INCREF(obj);
8705 return Py_BuildValue((char *)"");
8706 }
8707 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8708 PyObject *resultobj;
8709 wxTimer *arg1 = 0 ;
8710 wxTimerRunner *result;
8711 PyObject * obj0 = 0 ;
8712
8713 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8714 {
8715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8716 if (SWIG_arg_fail(1)) SWIG_fail;
8717 if (arg1 == NULL) {
8718 SWIG_null_ref("wxTimer");
8719 }
8720 if (SWIG_arg_fail(1)) SWIG_fail;
8721 }
8722 {
8723 if (!wxPyCheckForApp()) SWIG_fail;
8724 PyThreadState* __tstate = wxPyBeginAllowThreads();
8725 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8726
8727 wxPyEndAllowThreads(__tstate);
8728 if (PyErr_Occurred()) SWIG_fail;
8729 }
8730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8731 return resultobj;
8732 fail:
8733 return NULL;
8734 }
8735
8736
8737 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8738 PyObject *resultobj;
8739 wxTimer *arg1 = 0 ;
8740 int arg2 ;
8741 bool arg3 = (bool) false ;
8742 wxTimerRunner *result;
8743 PyObject * obj0 = 0 ;
8744 PyObject * obj1 = 0 ;
8745 PyObject * obj2 = 0 ;
8746
8747 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8748 {
8749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8750 if (SWIG_arg_fail(1)) SWIG_fail;
8751 if (arg1 == NULL) {
8752 SWIG_null_ref("wxTimer");
8753 }
8754 if (SWIG_arg_fail(1)) SWIG_fail;
8755 }
8756 {
8757 arg2 = (int)(SWIG_As_int(obj1));
8758 if (SWIG_arg_fail(2)) SWIG_fail;
8759 }
8760 if (obj2) {
8761 {
8762 arg3 = (bool)(SWIG_As_bool(obj2));
8763 if (SWIG_arg_fail(3)) SWIG_fail;
8764 }
8765 }
8766 {
8767 if (!wxPyCheckForApp()) SWIG_fail;
8768 PyThreadState* __tstate = wxPyBeginAllowThreads();
8769 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8770
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8782 int argc;
8783 PyObject *argv[4];
8784 int ii;
8785
8786 argc = PyObject_Length(args);
8787 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8788 argv[ii] = PyTuple_GetItem(args,ii);
8789 }
8790 if (argc == 1) {
8791 int _v;
8792 {
8793 void *ptr = 0;
8794 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8795 _v = 0;
8796 PyErr_Clear();
8797 } else {
8798 _v = (ptr != 0);
8799 }
8800 }
8801 if (_v) {
8802 return _wrap_new_TimerRunner__SWIG_0(self,args);
8803 }
8804 }
8805 if ((argc >= 2) && (argc <= 3)) {
8806 int _v;
8807 {
8808 void *ptr = 0;
8809 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8810 _v = 0;
8811 PyErr_Clear();
8812 } else {
8813 _v = (ptr != 0);
8814 }
8815 }
8816 if (_v) {
8817 _v = SWIG_Check_int(argv[1]);
8818 if (_v) {
8819 if (argc <= 2) {
8820 return _wrap_new_TimerRunner__SWIG_1(self,args);
8821 }
8822 _v = SWIG_Check_bool(argv[2]);
8823 if (_v) {
8824 return _wrap_new_TimerRunner__SWIG_1(self,args);
8825 }
8826 }
8827 }
8828 }
8829
8830 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8831 return NULL;
8832 }
8833
8834
8835 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj;
8837 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8838 PyObject * obj0 = 0 ;
8839 char *kwnames[] = {
8840 (char *) "self", NULL
8841 };
8842
8843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8845 if (SWIG_arg_fail(1)) SWIG_fail;
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 delete arg1;
8849
8850 wxPyEndAllowThreads(__tstate);
8851 if (PyErr_Occurred()) SWIG_fail;
8852 }
8853 Py_INCREF(Py_None); resultobj = Py_None;
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj;
8862 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8863 int arg2 ;
8864 bool arg3 = (bool) false ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 PyObject * obj2 = 0 ;
8868 char *kwnames[] = {
8869 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8870 };
8871
8872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8874 if (SWIG_arg_fail(1)) SWIG_fail;
8875 {
8876 arg2 = (int)(SWIG_As_int(obj1));
8877 if (SWIG_arg_fail(2)) SWIG_fail;
8878 }
8879 if (obj2) {
8880 {
8881 arg3 = (bool)(SWIG_As_bool(obj2));
8882 if (SWIG_arg_fail(3)) SWIG_fail;
8883 }
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 (arg1)->Start(arg2,arg3);
8888
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 Py_INCREF(Py_None); resultobj = Py_None;
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8900 PyObject *obj;
8901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8902 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8903 Py_INCREF(obj);
8904 return Py_BuildValue((char *)"");
8905 }
8906 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxLog *result;
8909 char *kwnames[] = {
8910 NULL
8911 };
8912
8913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 result = (wxLog *)new wxLog();
8917
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 bool result;
8931 char *kwnames[] = {
8932 NULL
8933 };
8934
8935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 result = (bool)wxLog::IsEnabled();
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 {
8944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8945 }
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj;
8954 bool arg1 = (bool) true ;
8955 bool result;
8956 PyObject * obj0 = 0 ;
8957 char *kwnames[] = {
8958 (char *) "doIt", NULL
8959 };
8960
8961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8962 if (obj0) {
8963 {
8964 arg1 = (bool)(SWIG_As_bool(obj0));
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 }
8967 }
8968 {
8969 PyThreadState* __tstate = wxPyBeginAllowThreads();
8970 result = (bool)wxLog::EnableLogging(arg1);
8971
8972 wxPyEndAllowThreads(__tstate);
8973 if (PyErr_Occurred()) SWIG_fail;
8974 }
8975 {
8976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8977 }
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj;
8986 wxLogLevel arg1 ;
8987 wxChar *arg2 = (wxChar *) 0 ;
8988 time_t arg3 ;
8989 PyObject * obj0 = 0 ;
8990 PyObject * obj1 = 0 ;
8991 PyObject * obj2 = 0 ;
8992 char *kwnames[] = {
8993 (char *) "level",(char *) "szString",(char *) "t", NULL
8994 };
8995
8996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8997 {
8998 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8999 if (SWIG_arg_fail(1)) SWIG_fail;
9000 }
9001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9002 if (SWIG_arg_fail(2)) SWIG_fail;
9003 {
9004 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
9005 if (SWIG_arg_fail(3)) SWIG_fail;
9006 }
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 Py_INCREF(Py_None); resultobj = Py_None;
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj;
9023 wxLog *arg1 = (wxLog *) 0 ;
9024 PyObject * obj0 = 0 ;
9025 char *kwnames[] = {
9026 (char *) "self", NULL
9027 };
9028
9029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9031 if (SWIG_arg_fail(1)) SWIG_fail;
9032 {
9033 PyThreadState* __tstate = wxPyBeginAllowThreads();
9034 (arg1)->Flush();
9035
9036 wxPyEndAllowThreads(__tstate);
9037 if (PyErr_Occurred()) SWIG_fail;
9038 }
9039 Py_INCREF(Py_None); resultobj = Py_None;
9040 return resultobj;
9041 fail:
9042 return NULL;
9043 }
9044
9045
9046 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9047 PyObject *resultobj;
9048 char *kwnames[] = {
9049 NULL
9050 };
9051
9052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 wxLog::FlushActive();
9056
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 Py_INCREF(Py_None); resultobj = Py_None;
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
9067 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj;
9069 wxLog *result;
9070 char *kwnames[] = {
9071 NULL
9072 };
9073
9074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 result = (wxLog *)wxLog::GetActiveTarget();
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 wxLog *arg1 = (wxLog *) 0 ;
9092 wxLog *result;
9093 PyObject * obj0 = 0 ;
9094 char *kwnames[] = {
9095 (char *) "pLogger", NULL
9096 };
9097
9098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9100 if (SWIG_arg_fail(1)) SWIG_fail;
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9104
9105 wxPyEndAllowThreads(__tstate);
9106 if (PyErr_Occurred()) SWIG_fail;
9107 }
9108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9109 return resultobj;
9110 fail:
9111 return NULL;
9112 }
9113
9114
9115 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9116 PyObject *resultobj;
9117 char *kwnames[] = {
9118 NULL
9119 };
9120
9121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 wxLog::Suspend();
9125
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 Py_INCREF(Py_None); resultobj = Py_None;
9130 return resultobj;
9131 fail:
9132 return NULL;
9133 }
9134
9135
9136 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9137 PyObject *resultobj;
9138 char *kwnames[] = {
9139 NULL
9140 };
9141
9142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9143 {
9144 PyThreadState* __tstate = wxPyBeginAllowThreads();
9145 wxLog::Resume();
9146
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 Py_INCREF(Py_None); resultobj = Py_None;
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 bool arg1 = (bool) true ;
9160 PyObject * obj0 = 0 ;
9161 char *kwnames[] = {
9162 (char *) "bVerbose", NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9166 if (obj0) {
9167 {
9168 arg1 = (bool)(SWIG_As_bool(obj0));
9169 if (SWIG_arg_fail(1)) SWIG_fail;
9170 }
9171 }
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 wxLog::SetVerbose(arg1);
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 Py_INCREF(Py_None); resultobj = Py_None;
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9187 PyObject *resultobj;
9188 wxLogLevel arg1 ;
9189 PyObject * obj0 = 0 ;
9190 char *kwnames[] = {
9191 (char *) "logLevel", NULL
9192 };
9193
9194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9195 {
9196 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9197 if (SWIG_arg_fail(1)) SWIG_fail;
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 wxLog::SetLogLevel(arg1);
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 Py_INCREF(Py_None); resultobj = Py_None;
9207 return resultobj;
9208 fail:
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 char *kwnames[] = {
9216 NULL
9217 };
9218
9219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9220 {
9221 PyThreadState* __tstate = wxPyBeginAllowThreads();
9222 wxLog::DontCreateOnDemand();
9223
9224 wxPyEndAllowThreads(__tstate);
9225 if (PyErr_Occurred()) SWIG_fail;
9226 }
9227 Py_INCREF(Py_None); resultobj = Py_None;
9228 return resultobj;
9229 fail:
9230 return NULL;
9231 }
9232
9233
9234 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9235 PyObject *resultobj;
9236 wxTraceMask arg1 ;
9237 PyObject * obj0 = 0 ;
9238 char *kwnames[] = {
9239 (char *) "ulMask", NULL
9240 };
9241
9242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9243 {
9244 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9245 if (SWIG_arg_fail(1)) SWIG_fail;
9246 }
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 wxLog::SetTraceMask(arg1);
9250
9251 wxPyEndAllowThreads(__tstate);
9252 if (PyErr_Occurred()) SWIG_fail;
9253 }
9254 Py_INCREF(Py_None); resultobj = Py_None;
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9262 PyObject *resultobj;
9263 wxString *arg1 = 0 ;
9264 bool temp1 = false ;
9265 PyObject * obj0 = 0 ;
9266 char *kwnames[] = {
9267 (char *) "str", NULL
9268 };
9269
9270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9271 {
9272 arg1 = wxString_in_helper(obj0);
9273 if (arg1 == NULL) SWIG_fail;
9274 temp1 = true;
9275 }
9276 {
9277 PyThreadState* __tstate = wxPyBeginAllowThreads();
9278 wxLog::AddTraceMask((wxString const &)*arg1);
9279
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 Py_INCREF(Py_None); resultobj = Py_None;
9284 {
9285 if (temp1)
9286 delete arg1;
9287 }
9288 return resultobj;
9289 fail:
9290 {
9291 if (temp1)
9292 delete arg1;
9293 }
9294 return NULL;
9295 }
9296
9297
9298 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 wxString *arg1 = 0 ;
9301 bool temp1 = false ;
9302 PyObject * obj0 = 0 ;
9303 char *kwnames[] = {
9304 (char *) "str", NULL
9305 };
9306
9307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9308 {
9309 arg1 = wxString_in_helper(obj0);
9310 if (arg1 == NULL) SWIG_fail;
9311 temp1 = true;
9312 }
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 wxLog::RemoveTraceMask((wxString const &)*arg1);
9316
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 Py_INCREF(Py_None); resultobj = Py_None;
9321 {
9322 if (temp1)
9323 delete arg1;
9324 }
9325 return resultobj;
9326 fail:
9327 {
9328 if (temp1)
9329 delete arg1;
9330 }
9331 return NULL;
9332 }
9333
9334
9335 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9336 PyObject *resultobj;
9337 char *kwnames[] = {
9338 NULL
9339 };
9340
9341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 wxLog::ClearTraceMasks();
9345
9346 wxPyEndAllowThreads(__tstate);
9347 if (PyErr_Occurred()) SWIG_fail;
9348 }
9349 Py_INCREF(Py_None); resultobj = Py_None;
9350 return resultobj;
9351 fail:
9352 return NULL;
9353 }
9354
9355
9356 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9357 PyObject *resultobj;
9358 wxArrayString *result;
9359 char *kwnames[] = {
9360 NULL
9361 };
9362
9363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9364 {
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 {
9367 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9368 result = (wxArrayString *) &_result_ref;
9369 }
9370
9371 wxPyEndAllowThreads(__tstate);
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 {
9375 resultobj = wxArrayString2PyList_helper(*result);
9376 }
9377 return resultobj;
9378 fail:
9379 return NULL;
9380 }
9381
9382
9383 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9384 PyObject *resultobj;
9385 wxChar *arg1 = (wxChar *) 0 ;
9386 PyObject * obj0 = 0 ;
9387 char *kwnames[] = {
9388 (char *) "ts", NULL
9389 };
9390
9391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9393 if (SWIG_arg_fail(1)) SWIG_fail;
9394 {
9395 PyThreadState* __tstate = wxPyBeginAllowThreads();
9396 wxLog::SetTimestamp((wxChar const *)arg1);
9397
9398 wxPyEndAllowThreads(__tstate);
9399 if (PyErr_Occurred()) SWIG_fail;
9400 }
9401 Py_INCREF(Py_None); resultobj = Py_None;
9402 return resultobj;
9403 fail:
9404 return NULL;
9405 }
9406
9407
9408 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9409 PyObject *resultobj;
9410 bool result;
9411 char *kwnames[] = {
9412 NULL
9413 };
9414
9415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9416 {
9417 PyThreadState* __tstate = wxPyBeginAllowThreads();
9418 result = (bool)wxLog::GetVerbose();
9419
9420 wxPyEndAllowThreads(__tstate);
9421 if (PyErr_Occurred()) SWIG_fail;
9422 }
9423 {
9424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9425 }
9426 return resultobj;
9427 fail:
9428 return NULL;
9429 }
9430
9431
9432 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9433 PyObject *resultobj;
9434 wxTraceMask result;
9435 char *kwnames[] = {
9436 NULL
9437 };
9438
9439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (wxTraceMask)wxLog::GetTraceMask();
9443
9444 wxPyEndAllowThreads(__tstate);
9445 if (PyErr_Occurred()) SWIG_fail;
9446 }
9447 {
9448 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9449 }
9450 return resultobj;
9451 fail:
9452 return NULL;
9453 }
9454
9455
9456 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxChar *arg1 = (wxChar *) 0 ;
9459 bool result;
9460 PyObject * obj0 = 0 ;
9461 char *kwnames[] = {
9462 (char *) "mask", NULL
9463 };
9464
9465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9467 if (SWIG_arg_fail(1)) SWIG_fail;
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9471
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 {
9476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9477 }
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj;
9486 wxLogLevel result;
9487 char *kwnames[] = {
9488 NULL
9489 };
9490
9491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (wxLogLevel)wxLog::GetLogLevel();
9495
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 {
9500 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9501 }
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj;
9510 wxChar *result;
9511 char *kwnames[] = {
9512 NULL
9513 };
9514
9515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9516 {
9517 PyThreadState* __tstate = wxPyBeginAllowThreads();
9518 result = (wxChar *)wxLog::GetTimestamp();
9519
9520 wxPyEndAllowThreads(__tstate);
9521 if (PyErr_Occurred()) SWIG_fail;
9522 }
9523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9531 PyObject *resultobj;
9532 wxString result;
9533 char *kwnames[] = {
9534 NULL
9535 };
9536
9537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9538 {
9539 PyThreadState* __tstate = wxPyBeginAllowThreads();
9540 result = Log_TimeStamp();
9541
9542 wxPyEndAllowThreads(__tstate);
9543 if (PyErr_Occurred()) SWIG_fail;
9544 }
9545 {
9546 #if wxUSE_UNICODE
9547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9548 #else
9549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9550 #endif
9551 }
9552 return resultobj;
9553 fail:
9554 return NULL;
9555 }
9556
9557
9558 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj;
9560 wxLog *arg1 = (wxLog *) 0 ;
9561 PyObject * obj0 = 0 ;
9562 char *kwnames[] = {
9563 (char *) "self", NULL
9564 };
9565
9566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9568 if (SWIG_arg_fail(1)) SWIG_fail;
9569 {
9570 PyThreadState* __tstate = wxPyBeginAllowThreads();
9571 wxLog_Destroy(arg1);
9572
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 Py_INCREF(Py_None); resultobj = Py_None;
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9584 PyObject *obj;
9585 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9586 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9587 Py_INCREF(obj);
9588 return Py_BuildValue((char *)"");
9589 }
9590 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9591 PyObject *resultobj;
9592 wxLogStderr *result;
9593 char *kwnames[] = {
9594 NULL
9595 };
9596
9597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 result = (wxLogStderr *)new wxLogStderr();
9601
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9613 PyObject *obj;
9614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9615 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9616 Py_INCREF(obj);
9617 return Py_BuildValue((char *)"");
9618 }
9619 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj;
9621 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9622 wxLogTextCtrl *result;
9623 PyObject * obj0 = 0 ;
9624 char *kwnames[] = {
9625 (char *) "pTextCtrl", NULL
9626 };
9627
9628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9630 if (SWIG_arg_fail(1)) SWIG_fail;
9631 {
9632 PyThreadState* __tstate = wxPyBeginAllowThreads();
9633 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9634
9635 wxPyEndAllowThreads(__tstate);
9636 if (PyErr_Occurred()) SWIG_fail;
9637 }
9638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9646 PyObject *obj;
9647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9648 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9649 Py_INCREF(obj);
9650 return Py_BuildValue((char *)"");
9651 }
9652 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9653 PyObject *resultobj;
9654 wxLogGui *result;
9655 char *kwnames[] = {
9656 NULL
9657 };
9658
9659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9660 {
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 result = (wxLogGui *)new wxLogGui();
9663
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9675 PyObject *obj;
9676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9677 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9678 Py_INCREF(obj);
9679 return Py_BuildValue((char *)"");
9680 }
9681 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj;
9683 wxFrame *arg1 = (wxFrame *) 0 ;
9684 wxString *arg2 = 0 ;
9685 bool arg3 = (bool) true ;
9686 bool arg4 = (bool) true ;
9687 wxLogWindow *result;
9688 bool temp2 = false ;
9689 PyObject * obj0 = 0 ;
9690 PyObject * obj1 = 0 ;
9691 PyObject * obj2 = 0 ;
9692 PyObject * obj3 = 0 ;
9693 char *kwnames[] = {
9694 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9695 };
9696
9697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9699 if (SWIG_arg_fail(1)) SWIG_fail;
9700 {
9701 arg2 = wxString_in_helper(obj1);
9702 if (arg2 == NULL) SWIG_fail;
9703 temp2 = true;
9704 }
9705 if (obj2) {
9706 {
9707 arg3 = (bool)(SWIG_As_bool(obj2));
9708 if (SWIG_arg_fail(3)) SWIG_fail;
9709 }
9710 }
9711 if (obj3) {
9712 {
9713 arg4 = (bool)(SWIG_As_bool(obj3));
9714 if (SWIG_arg_fail(4)) SWIG_fail;
9715 }
9716 }
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9725 {
9726 if (temp2)
9727 delete arg2;
9728 }
9729 return resultobj;
9730 fail:
9731 {
9732 if (temp2)
9733 delete arg2;
9734 }
9735 return NULL;
9736 }
9737
9738
9739 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj;
9741 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9742 bool arg2 = (bool) true ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char *kwnames[] = {
9746 (char *) "self",(char *) "bShow", NULL
9747 };
9748
9749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9751 if (SWIG_arg_fail(1)) SWIG_fail;
9752 if (obj1) {
9753 {
9754 arg2 = (bool)(SWIG_As_bool(obj1));
9755 if (SWIG_arg_fail(2)) SWIG_fail;
9756 }
9757 }
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 (arg1)->Show(arg2);
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 Py_INCREF(Py_None); resultobj = Py_None;
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj;
9774 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9775 wxFrame *result;
9776 PyObject * obj0 = 0 ;
9777 char *kwnames[] = {
9778 (char *) "self", NULL
9779 };
9780
9781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9783 if (SWIG_arg_fail(1)) SWIG_fail;
9784 {
9785 PyThreadState* __tstate = wxPyBeginAllowThreads();
9786 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9787
9788 wxPyEndAllowThreads(__tstate);
9789 if (PyErr_Occurred()) SWIG_fail;
9790 }
9791 {
9792 resultobj = wxPyMake_wxObject(result, 0);
9793 }
9794 return resultobj;
9795 fail:
9796 return NULL;
9797 }
9798
9799
9800 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9801 PyObject *resultobj;
9802 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9803 wxLog *result;
9804 PyObject * obj0 = 0 ;
9805 char *kwnames[] = {
9806 (char *) "self", NULL
9807 };
9808
9809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9811 if (SWIG_arg_fail(1)) SWIG_fail;
9812 {
9813 PyThreadState* __tstate = wxPyBeginAllowThreads();
9814 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9815
9816 wxPyEndAllowThreads(__tstate);
9817 if (PyErr_Occurred()) SWIG_fail;
9818 }
9819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9820 return resultobj;
9821 fail:
9822 return NULL;
9823 }
9824
9825
9826 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9827 PyObject *resultobj;
9828 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9829 bool result;
9830 PyObject * obj0 = 0 ;
9831 char *kwnames[] = {
9832 (char *) "self", NULL
9833 };
9834
9835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9837 if (SWIG_arg_fail(1)) SWIG_fail;
9838 {
9839 PyThreadState* __tstate = wxPyBeginAllowThreads();
9840 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9841
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 {
9846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9847 }
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9857 bool arg2 ;
9858 PyObject * obj0 = 0 ;
9859 PyObject * obj1 = 0 ;
9860 char *kwnames[] = {
9861 (char *) "self",(char *) "bDoPass", NULL
9862 };
9863
9864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9866 if (SWIG_arg_fail(1)) SWIG_fail;
9867 {
9868 arg2 = (bool)(SWIG_As_bool(obj1));
9869 if (SWIG_arg_fail(2)) SWIG_fail;
9870 }
9871 {
9872 PyThreadState* __tstate = wxPyBeginAllowThreads();
9873 (arg1)->PassMessages(arg2);
9874
9875 wxPyEndAllowThreads(__tstate);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 Py_INCREF(Py_None); resultobj = Py_None;
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9886 PyObject *obj;
9887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9888 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9889 Py_INCREF(obj);
9890 return Py_BuildValue((char *)"");
9891 }
9892 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj;
9894 wxLog *arg1 = (wxLog *) 0 ;
9895 wxLogChain *result;
9896 PyObject * obj0 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "logger", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (wxLogChain *)new wxLogChain(arg1);
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9919 PyObject *resultobj;
9920 wxLogChain *arg1 = (wxLogChain *) 0 ;
9921 wxLog *arg2 = (wxLog *) 0 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self",(char *) "logger", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9932 if (SWIG_arg_fail(2)) SWIG_fail;
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 (arg1)->SetLog(arg2);
9936
9937 wxPyEndAllowThreads(__tstate);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 Py_INCREF(Py_None); resultobj = Py_None;
9941 return resultobj;
9942 fail:
9943 return NULL;
9944 }
9945
9946
9947 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9948 PyObject *resultobj;
9949 wxLogChain *arg1 = (wxLogChain *) 0 ;
9950 bool arg2 ;
9951 PyObject * obj0 = 0 ;
9952 PyObject * obj1 = 0 ;
9953 char *kwnames[] = {
9954 (char *) "self",(char *) "bDoPass", NULL
9955 };
9956
9957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9959 if (SWIG_arg_fail(1)) SWIG_fail;
9960 {
9961 arg2 = (bool)(SWIG_As_bool(obj1));
9962 if (SWIG_arg_fail(2)) SWIG_fail;
9963 }
9964 {
9965 PyThreadState* __tstate = wxPyBeginAllowThreads();
9966 (arg1)->PassMessages(arg2);
9967
9968 wxPyEndAllowThreads(__tstate);
9969 if (PyErr_Occurred()) SWIG_fail;
9970 }
9971 Py_INCREF(Py_None); resultobj = Py_None;
9972 return resultobj;
9973 fail:
9974 return NULL;
9975 }
9976
9977
9978 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9979 PyObject *resultobj;
9980 wxLogChain *arg1 = (wxLogChain *) 0 ;
9981 bool result;
9982 PyObject * obj0 = 0 ;
9983 char *kwnames[] = {
9984 (char *) "self", NULL
9985 };
9986
9987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9989 if (SWIG_arg_fail(1)) SWIG_fail;
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (bool)(arg1)->IsPassingMessages();
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 {
9998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9999 }
10000 return resultobj;
10001 fail:
10002 return NULL;
10003 }
10004
10005
10006 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10007 PyObject *resultobj;
10008 wxLogChain *arg1 = (wxLogChain *) 0 ;
10009 wxLog *result;
10010 PyObject * obj0 = 0 ;
10011 char *kwnames[] = {
10012 (char *) "self", NULL
10013 };
10014
10015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10017 if (SWIG_arg_fail(1)) SWIG_fail;
10018 {
10019 PyThreadState* __tstate = wxPyBeginAllowThreads();
10020 result = (wxLog *)(arg1)->GetOldLog();
10021
10022 wxPyEndAllowThreads(__tstate);
10023 if (PyErr_Occurred()) SWIG_fail;
10024 }
10025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10026 return resultobj;
10027 fail:
10028 return NULL;
10029 }
10030
10031
10032 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10033 PyObject *obj;
10034 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10035 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10036 Py_INCREF(obj);
10037 return Py_BuildValue((char *)"");
10038 }
10039 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj;
10041 wxLogBuffer *result;
10042 char *kwnames[] = {
10043 NULL
10044 };
10045
10046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10047 {
10048 PyThreadState* __tstate = wxPyBeginAllowThreads();
10049 result = (wxLogBuffer *)new wxLogBuffer();
10050
10051 wxPyEndAllowThreads(__tstate);
10052 if (PyErr_Occurred()) SWIG_fail;
10053 }
10054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10055 return resultobj;
10056 fail:
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10064 wxString *result;
10065 PyObject * obj0 = 0 ;
10066 char *kwnames[] = {
10067 (char *) "self", NULL
10068 };
10069
10070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
10071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10072 if (SWIG_arg_fail(1)) SWIG_fail;
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 {
10076 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10077 result = (wxString *) &_result_ref;
10078 }
10079
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 #if wxUSE_UNICODE
10085 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10086 #else
10087 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10088 #endif
10089 }
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10099 PyObject * obj0 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "self", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10106 if (SWIG_arg_fail(1)) SWIG_fail;
10107 {
10108 PyThreadState* __tstate = wxPyBeginAllowThreads();
10109 (arg1)->Flush();
10110
10111 wxPyEndAllowThreads(__tstate);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 Py_INCREF(Py_None); resultobj = Py_None;
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10122 PyObject *obj;
10123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10124 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10125 Py_INCREF(obj);
10126 return Py_BuildValue((char *)"");
10127 }
10128 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10129 PyObject *resultobj;
10130 unsigned long result;
10131 char *kwnames[] = {
10132 NULL
10133 };
10134
10135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 result = (unsigned long)wxSysErrorCode();
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 {
10144 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10145 }
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj;
10154 unsigned long arg1 = (unsigned long) 0 ;
10155 wxString result;
10156 PyObject * obj0 = 0 ;
10157 char *kwnames[] = {
10158 (char *) "nErrCode", NULL
10159 };
10160
10161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10162 if (obj0) {
10163 {
10164 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10165 if (SWIG_arg_fail(1)) SWIG_fail;
10166 }
10167 }
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 result = wxSysErrorMsg(arg1);
10171
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 {
10176 #if wxUSE_UNICODE
10177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10178 #else
10179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10180 #endif
10181 }
10182 return resultobj;
10183 fail:
10184 return NULL;
10185 }
10186
10187
10188 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10189 PyObject *resultobj;
10190 wxString *arg1 = 0 ;
10191 bool temp1 = false ;
10192 PyObject * obj0 = 0 ;
10193 char *kwnames[] = {
10194 (char *) "msg", NULL
10195 };
10196
10197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10198 {
10199 arg1 = wxString_in_helper(obj0);
10200 if (arg1 == NULL) SWIG_fail;
10201 temp1 = true;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 wxPyLogFatalError((wxString const &)*arg1);
10206
10207 wxPyEndAllowThreads(__tstate);
10208 if (PyErr_Occurred()) SWIG_fail;
10209 }
10210 Py_INCREF(Py_None); resultobj = Py_None;
10211 {
10212 if (temp1)
10213 delete arg1;
10214 }
10215 return resultobj;
10216 fail:
10217 {
10218 if (temp1)
10219 delete arg1;
10220 }
10221 return NULL;
10222 }
10223
10224
10225 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10226 PyObject *resultobj;
10227 wxString *arg1 = 0 ;
10228 bool temp1 = false ;
10229 PyObject * obj0 = 0 ;
10230 char *kwnames[] = {
10231 (char *) "msg", NULL
10232 };
10233
10234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10235 {
10236 arg1 = wxString_in_helper(obj0);
10237 if (arg1 == NULL) SWIG_fail;
10238 temp1 = true;
10239 }
10240 {
10241 PyThreadState* __tstate = wxPyBeginAllowThreads();
10242 wxPyLogError((wxString const &)*arg1);
10243
10244 wxPyEndAllowThreads(__tstate);
10245 if (PyErr_Occurred()) SWIG_fail;
10246 }
10247 Py_INCREF(Py_None); resultobj = Py_None;
10248 {
10249 if (temp1)
10250 delete arg1;
10251 }
10252 return resultobj;
10253 fail:
10254 {
10255 if (temp1)
10256 delete arg1;
10257 }
10258 return NULL;
10259 }
10260
10261
10262 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10263 PyObject *resultobj;
10264 wxString *arg1 = 0 ;
10265 bool temp1 = false ;
10266 PyObject * obj0 = 0 ;
10267 char *kwnames[] = {
10268 (char *) "msg", NULL
10269 };
10270
10271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10272 {
10273 arg1 = wxString_in_helper(obj0);
10274 if (arg1 == NULL) SWIG_fail;
10275 temp1 = true;
10276 }
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 wxPyLogWarning((wxString const &)*arg1);
10280
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 Py_INCREF(Py_None); resultobj = Py_None;
10285 {
10286 if (temp1)
10287 delete arg1;
10288 }
10289 return resultobj;
10290 fail:
10291 {
10292 if (temp1)
10293 delete arg1;
10294 }
10295 return NULL;
10296 }
10297
10298
10299 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10300 PyObject *resultobj;
10301 wxString *arg1 = 0 ;
10302 bool temp1 = false ;
10303 PyObject * obj0 = 0 ;
10304 char *kwnames[] = {
10305 (char *) "msg", NULL
10306 };
10307
10308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10309 {
10310 arg1 = wxString_in_helper(obj0);
10311 if (arg1 == NULL) SWIG_fail;
10312 temp1 = true;
10313 }
10314 {
10315 PyThreadState* __tstate = wxPyBeginAllowThreads();
10316 wxPyLogMessage((wxString const &)*arg1);
10317
10318 wxPyEndAllowThreads(__tstate);
10319 if (PyErr_Occurred()) SWIG_fail;
10320 }
10321 Py_INCREF(Py_None); resultobj = Py_None;
10322 {
10323 if (temp1)
10324 delete arg1;
10325 }
10326 return resultobj;
10327 fail:
10328 {
10329 if (temp1)
10330 delete arg1;
10331 }
10332 return NULL;
10333 }
10334
10335
10336 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10337 PyObject *resultobj;
10338 wxString *arg1 = 0 ;
10339 bool temp1 = false ;
10340 PyObject * obj0 = 0 ;
10341 char *kwnames[] = {
10342 (char *) "msg", NULL
10343 };
10344
10345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10346 {
10347 arg1 = wxString_in_helper(obj0);
10348 if (arg1 == NULL) SWIG_fail;
10349 temp1 = true;
10350 }
10351 {
10352 PyThreadState* __tstate = wxPyBeginAllowThreads();
10353 wxPyLogInfo((wxString const &)*arg1);
10354
10355 wxPyEndAllowThreads(__tstate);
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 Py_INCREF(Py_None); resultobj = Py_None;
10359 {
10360 if (temp1)
10361 delete arg1;
10362 }
10363 return resultobj;
10364 fail:
10365 {
10366 if (temp1)
10367 delete arg1;
10368 }
10369 return NULL;
10370 }
10371
10372
10373 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj;
10375 wxString *arg1 = 0 ;
10376 bool temp1 = false ;
10377 PyObject * obj0 = 0 ;
10378 char *kwnames[] = {
10379 (char *) "msg", NULL
10380 };
10381
10382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10383 {
10384 arg1 = wxString_in_helper(obj0);
10385 if (arg1 == NULL) SWIG_fail;
10386 temp1 = true;
10387 }
10388 {
10389 PyThreadState* __tstate = wxPyBeginAllowThreads();
10390 wxPyLogDebug((wxString const &)*arg1);
10391
10392 wxPyEndAllowThreads(__tstate);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 Py_INCREF(Py_None); resultobj = Py_None;
10396 {
10397 if (temp1)
10398 delete arg1;
10399 }
10400 return resultobj;
10401 fail:
10402 {
10403 if (temp1)
10404 delete arg1;
10405 }
10406 return NULL;
10407 }
10408
10409
10410 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10411 PyObject *resultobj;
10412 wxString *arg1 = 0 ;
10413 bool temp1 = false ;
10414 PyObject * obj0 = 0 ;
10415 char *kwnames[] = {
10416 (char *) "msg", NULL
10417 };
10418
10419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10420 {
10421 arg1 = wxString_in_helper(obj0);
10422 if (arg1 == NULL) SWIG_fail;
10423 temp1 = true;
10424 }
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 wxPyLogVerbose((wxString const &)*arg1);
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 Py_INCREF(Py_None); resultobj = Py_None;
10433 {
10434 if (temp1)
10435 delete arg1;
10436 }
10437 return resultobj;
10438 fail:
10439 {
10440 if (temp1)
10441 delete arg1;
10442 }
10443 return NULL;
10444 }
10445
10446
10447 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj;
10449 wxString *arg1 = 0 ;
10450 bool temp1 = false ;
10451 PyObject * obj0 = 0 ;
10452 char *kwnames[] = {
10453 (char *) "msg", NULL
10454 };
10455
10456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10457 {
10458 arg1 = wxString_in_helper(obj0);
10459 if (arg1 == NULL) SWIG_fail;
10460 temp1 = true;
10461 }
10462 {
10463 PyThreadState* __tstate = wxPyBeginAllowThreads();
10464 wxPyLogStatus((wxString const &)*arg1);
10465
10466 wxPyEndAllowThreads(__tstate);
10467 if (PyErr_Occurred()) SWIG_fail;
10468 }
10469 Py_INCREF(Py_None); resultobj = Py_None;
10470 {
10471 if (temp1)
10472 delete arg1;
10473 }
10474 return resultobj;
10475 fail:
10476 {
10477 if (temp1)
10478 delete arg1;
10479 }
10480 return NULL;
10481 }
10482
10483
10484 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10485 PyObject *resultobj;
10486 wxFrame *arg1 = (wxFrame *) 0 ;
10487 wxString *arg2 = 0 ;
10488 bool temp2 = false ;
10489 PyObject * obj0 = 0 ;
10490 PyObject * obj1 = 0 ;
10491 char *kwnames[] = {
10492 (char *) "pFrame",(char *) "msg", NULL
10493 };
10494
10495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10497 if (SWIG_arg_fail(1)) SWIG_fail;
10498 {
10499 arg2 = wxString_in_helper(obj1);
10500 if (arg2 == NULL) SWIG_fail;
10501 temp2 = true;
10502 }
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10506
10507 wxPyEndAllowThreads(__tstate);
10508 if (PyErr_Occurred()) SWIG_fail;
10509 }
10510 Py_INCREF(Py_None); resultobj = Py_None;
10511 {
10512 if (temp2)
10513 delete arg2;
10514 }
10515 return resultobj;
10516 fail:
10517 {
10518 if (temp2)
10519 delete arg2;
10520 }
10521 return NULL;
10522 }
10523
10524
10525 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10526 PyObject *resultobj;
10527 wxString *arg1 = 0 ;
10528 bool temp1 = false ;
10529 PyObject * obj0 = 0 ;
10530 char *kwnames[] = {
10531 (char *) "msg", NULL
10532 };
10533
10534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10535 {
10536 arg1 = wxString_in_helper(obj0);
10537 if (arg1 == NULL) SWIG_fail;
10538 temp1 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 wxPyLogSysError((wxString const &)*arg1);
10543
10544 wxPyEndAllowThreads(__tstate);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 Py_INCREF(Py_None); resultobj = Py_None;
10548 {
10549 if (temp1)
10550 delete arg1;
10551 }
10552 return resultobj;
10553 fail:
10554 {
10555 if (temp1)
10556 delete arg1;
10557 }
10558 return NULL;
10559 }
10560
10561
10562 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10563 PyObject *resultobj;
10564 unsigned long arg1 ;
10565 wxString *arg2 = 0 ;
10566 bool temp2 = false ;
10567 PyObject * obj0 = 0 ;
10568 PyObject * obj1 = 0 ;
10569 char *kwnames[] = {
10570 (char *) "level",(char *) "msg", NULL
10571 };
10572
10573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10574 {
10575 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10576 if (SWIG_arg_fail(1)) SWIG_fail;
10577 }
10578 {
10579 arg2 = wxString_in_helper(obj1);
10580 if (arg2 == NULL) SWIG_fail;
10581 temp2 = true;
10582 }
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10586
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 Py_INCREF(Py_None); resultobj = Py_None;
10591 {
10592 if (temp2)
10593 delete arg2;
10594 }
10595 return resultobj;
10596 fail:
10597 {
10598 if (temp2)
10599 delete arg2;
10600 }
10601 return NULL;
10602 }
10603
10604
10605 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10606 PyObject *resultobj;
10607 unsigned long arg1 ;
10608 wxString *arg2 = 0 ;
10609 bool temp2 = false ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612
10613 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10614 {
10615 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10616 if (SWIG_arg_fail(1)) SWIG_fail;
10617 }
10618 {
10619 arg2 = wxString_in_helper(obj1);
10620 if (arg2 == NULL) SWIG_fail;
10621 temp2 = true;
10622 }
10623 {
10624 PyThreadState* __tstate = wxPyBeginAllowThreads();
10625 wxPyLogTrace(arg1,(wxString const &)*arg2);
10626
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 Py_INCREF(Py_None); resultobj = Py_None;
10631 {
10632 if (temp2)
10633 delete arg2;
10634 }
10635 return resultobj;
10636 fail:
10637 {
10638 if (temp2)
10639 delete arg2;
10640 }
10641 return NULL;
10642 }
10643
10644
10645 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10646 PyObject *resultobj;
10647 wxString *arg1 = 0 ;
10648 wxString *arg2 = 0 ;
10649 bool temp1 = false ;
10650 bool temp2 = false ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653
10654 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10655 {
10656 arg1 = wxString_in_helper(obj0);
10657 if (arg1 == NULL) SWIG_fail;
10658 temp1 = true;
10659 }
10660 {
10661 arg2 = wxString_in_helper(obj1);
10662 if (arg2 == NULL) SWIG_fail;
10663 temp2 = true;
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 Py_INCREF(Py_None); resultobj = Py_None;
10673 {
10674 if (temp1)
10675 delete arg1;
10676 }
10677 {
10678 if (temp2)
10679 delete arg2;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp1)
10685 delete arg1;
10686 }
10687 {
10688 if (temp2)
10689 delete arg2;
10690 }
10691 return NULL;
10692 }
10693
10694
10695 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10696 int argc;
10697 PyObject *argv[3];
10698 int ii;
10699
10700 argc = PyObject_Length(args);
10701 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10702 argv[ii] = PyTuple_GetItem(args,ii);
10703 }
10704 if (argc == 2) {
10705 int _v;
10706 {
10707 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10708 }
10709 if (_v) {
10710 {
10711 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10712 }
10713 if (_v) {
10714 return _wrap_LogTrace__SWIG_1(self,args);
10715 }
10716 }
10717 }
10718 if (argc == 2) {
10719 int _v;
10720 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10721 if (_v) {
10722 {
10723 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10724 }
10725 if (_v) {
10726 return _wrap_LogTrace__SWIG_0(self,args);
10727 }
10728 }
10729 }
10730
10731 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10732 return NULL;
10733 }
10734
10735
10736 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10737 PyObject *resultobj;
10738 wxString *arg1 = 0 ;
10739 wxString *arg2 = 0 ;
10740 bool temp1 = false ;
10741 bool temp2 = false ;
10742 PyObject * obj0 = 0 ;
10743 PyObject * obj1 = 0 ;
10744 char *kwnames[] = {
10745 (char *) "title",(char *) "text", NULL
10746 };
10747
10748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10749 {
10750 arg1 = wxString_in_helper(obj0);
10751 if (arg1 == NULL) SWIG_fail;
10752 temp1 = true;
10753 }
10754 {
10755 arg2 = wxString_in_helper(obj1);
10756 if (arg2 == NULL) SWIG_fail;
10757 temp2 = true;
10758 }
10759 {
10760 PyThreadState* __tstate = wxPyBeginAllowThreads();
10761 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10762
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 Py_INCREF(Py_None); resultobj = Py_None;
10767 {
10768 if (temp1)
10769 delete arg1;
10770 }
10771 {
10772 if (temp2)
10773 delete arg2;
10774 }
10775 return resultobj;
10776 fail:
10777 {
10778 if (temp1)
10779 delete arg1;
10780 }
10781 {
10782 if (temp2)
10783 delete arg2;
10784 }
10785 return NULL;
10786 }
10787
10788
10789 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10790 PyObject *resultobj;
10791 wxLogNull *result;
10792 char *kwnames[] = {
10793 NULL
10794 };
10795
10796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10797 {
10798 PyThreadState* __tstate = wxPyBeginAllowThreads();
10799 result = (wxLogNull *)new wxLogNull();
10800
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxLogNull *arg1 = (wxLogNull *) 0 ;
10814 PyObject * obj0 = 0 ;
10815 char *kwnames[] = {
10816 (char *) "self", NULL
10817 };
10818
10819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10821 if (SWIG_arg_fail(1)) SWIG_fail;
10822 {
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 delete arg1;
10825
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 Py_INCREF(Py_None); resultobj = Py_None;
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10837 PyObject *obj;
10838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10839 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10840 Py_INCREF(obj);
10841 return Py_BuildValue((char *)"");
10842 }
10843 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10844 PyObject *resultobj;
10845 wxPyLog *result;
10846 char *kwnames[] = {
10847 NULL
10848 };
10849
10850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10851 {
10852 PyThreadState* __tstate = wxPyBeginAllowThreads();
10853 result = (wxPyLog *)new wxPyLog();
10854
10855 wxPyEndAllowThreads(__tstate);
10856 if (PyErr_Occurred()) SWIG_fail;
10857 }
10858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10859 return resultobj;
10860 fail:
10861 return NULL;
10862 }
10863
10864
10865 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10866 PyObject *resultobj;
10867 wxPyLog *arg1 = (wxPyLog *) 0 ;
10868 PyObject *arg2 = (PyObject *) 0 ;
10869 PyObject *arg3 = (PyObject *) 0 ;
10870 PyObject * obj0 = 0 ;
10871 PyObject * obj1 = 0 ;
10872 PyObject * obj2 = 0 ;
10873 char *kwnames[] = {
10874 (char *) "self",(char *) "self",(char *) "_class", NULL
10875 };
10876
10877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10879 if (SWIG_arg_fail(1)) SWIG_fail;
10880 arg2 = obj1;
10881 arg3 = obj2;
10882 {
10883 PyThreadState* __tstate = wxPyBeginAllowThreads();
10884 (arg1)->_setCallbackInfo(arg2,arg3);
10885
10886 wxPyEndAllowThreads(__tstate);
10887 if (PyErr_Occurred()) SWIG_fail;
10888 }
10889 Py_INCREF(Py_None); resultobj = Py_None;
10890 return resultobj;
10891 fail:
10892 return NULL;
10893 }
10894
10895
10896 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10897 PyObject *obj;
10898 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10899 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10900 Py_INCREF(obj);
10901 return Py_BuildValue((char *)"");
10902 }
10903 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 int arg1 ;
10906 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10907 int arg3 = (int) wxKILL_NOCHILDREN ;
10908 wxKillError result;
10909 PyObject * obj0 = 0 ;
10910 PyObject * obj1 = 0 ;
10911 PyObject * obj2 = 0 ;
10912 char *kwnames[] = {
10913 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10914 };
10915
10916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10917 {
10918 arg1 = (int)(SWIG_As_int(obj0));
10919 if (SWIG_arg_fail(1)) SWIG_fail;
10920 }
10921 if (obj1) {
10922 {
10923 arg2 = (wxSignal)(SWIG_As_int(obj1));
10924 if (SWIG_arg_fail(2)) SWIG_fail;
10925 }
10926 }
10927 if (obj2) {
10928 {
10929 arg3 = (int)(SWIG_As_int(obj2));
10930 if (SWIG_arg_fail(3)) SWIG_fail;
10931 }
10932 }
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10936
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_From_int((result));
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj;
10949 int arg1 ;
10950 bool result;
10951 PyObject * obj0 = 0 ;
10952 char *kwnames[] = {
10953 (char *) "pid", NULL
10954 };
10955
10956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10957 {
10958 arg1 = (int)(SWIG_As_int(obj0));
10959 if (SWIG_arg_fail(1)) SWIG_fail;
10960 }
10961 {
10962 PyThreadState* __tstate = wxPyBeginAllowThreads();
10963 result = (bool)wxPyProcess::Exists(arg1);
10964
10965 wxPyEndAllowThreads(__tstate);
10966 if (PyErr_Occurred()) SWIG_fail;
10967 }
10968 {
10969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10970 }
10971 return resultobj;
10972 fail:
10973 return NULL;
10974 }
10975
10976
10977 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10978 PyObject *resultobj;
10979 wxString *arg1 = 0 ;
10980 int arg2 = (int) wxEXEC_ASYNC ;
10981 wxPyProcess *result;
10982 bool temp1 = false ;
10983 PyObject * obj0 = 0 ;
10984 PyObject * obj1 = 0 ;
10985 char *kwnames[] = {
10986 (char *) "cmd",(char *) "flags", NULL
10987 };
10988
10989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10990 {
10991 arg1 = wxString_in_helper(obj0);
10992 if (arg1 == NULL) SWIG_fail;
10993 temp1 = true;
10994 }
10995 if (obj1) {
10996 {
10997 arg2 = (int)(SWIG_As_int(obj1));
10998 if (SWIG_arg_fail(2)) SWIG_fail;
10999 }
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11004
11005 wxPyEndAllowThreads(__tstate);
11006 if (PyErr_Occurred()) SWIG_fail;
11007 }
11008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11009 {
11010 if (temp1)
11011 delete arg1;
11012 }
11013 return resultobj;
11014 fail:
11015 {
11016 if (temp1)
11017 delete arg1;
11018 }
11019 return NULL;
11020 }
11021
11022
11023 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj;
11025 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11026 int arg2 = (int) -1 ;
11027 wxPyProcess *result;
11028 PyObject * obj0 = 0 ;
11029 PyObject * obj1 = 0 ;
11030 char *kwnames[] = {
11031 (char *) "parent",(char *) "id", NULL
11032 };
11033
11034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11035 if (obj0) {
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 }
11039 if (obj1) {
11040 {
11041 arg2 = (int)(SWIG_As_int(obj1));
11042 if (SWIG_arg_fail(2)) SWIG_fail;
11043 }
11044 }
11045 {
11046 PyThreadState* __tstate = wxPyBeginAllowThreads();
11047 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11048
11049 wxPyEndAllowThreads(__tstate);
11050 if (PyErr_Occurred()) SWIG_fail;
11051 }
11052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11053 return resultobj;
11054 fail:
11055 return NULL;
11056 }
11057
11058
11059 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj;
11061 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11062 PyObject *arg2 = (PyObject *) 0 ;
11063 PyObject *arg3 = (PyObject *) 0 ;
11064 PyObject * obj0 = 0 ;
11065 PyObject * obj1 = 0 ;
11066 PyObject * obj2 = 0 ;
11067 char *kwnames[] = {
11068 (char *) "self",(char *) "self",(char *) "_class", NULL
11069 };
11070
11071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11073 if (SWIG_arg_fail(1)) SWIG_fail;
11074 arg2 = obj1;
11075 arg3 = obj2;
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 (arg1)->_setCallbackInfo(arg2,arg3);
11079
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 Py_INCREF(Py_None); resultobj = Py_None;
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj;
11092 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11093 int arg2 ;
11094 int arg3 ;
11095 PyObject * obj0 = 0 ;
11096 PyObject * obj1 = 0 ;
11097 PyObject * obj2 = 0 ;
11098 char *kwnames[] = {
11099 (char *) "self",(char *) "pid",(char *) "status", NULL
11100 };
11101
11102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11104 if (SWIG_arg_fail(1)) SWIG_fail;
11105 {
11106 arg2 = (int)(SWIG_As_int(obj1));
11107 if (SWIG_arg_fail(2)) SWIG_fail;
11108 }
11109 {
11110 arg3 = (int)(SWIG_As_int(obj2));
11111 if (SWIG_arg_fail(3)) SWIG_fail;
11112 }
11113 {
11114 PyThreadState* __tstate = wxPyBeginAllowThreads();
11115 (arg1)->base_OnTerminate(arg2,arg3);
11116
11117 wxPyEndAllowThreads(__tstate);
11118 if (PyErr_Occurred()) SWIG_fail;
11119 }
11120 Py_INCREF(Py_None); resultobj = Py_None;
11121 return resultobj;
11122 fail:
11123 return NULL;
11124 }
11125
11126
11127 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11128 PyObject *resultobj;
11129 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11130 PyObject * obj0 = 0 ;
11131 char *kwnames[] = {
11132 (char *) "self", NULL
11133 };
11134
11135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11137 if (SWIG_arg_fail(1)) SWIG_fail;
11138 {
11139 PyThreadState* __tstate = wxPyBeginAllowThreads();
11140 (arg1)->Redirect();
11141
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 Py_INCREF(Py_None); resultobj = Py_None;
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj;
11154 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11155 bool result;
11156 PyObject * obj0 = 0 ;
11157 char *kwnames[] = {
11158 (char *) "self", NULL
11159 };
11160
11161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11163 if (SWIG_arg_fail(1)) SWIG_fail;
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 result = (bool)(arg1)->IsRedirected();
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 {
11172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11173 }
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11181 PyObject *resultobj;
11182 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 (arg1)->Detach();
11194
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 Py_INCREF(Py_None); resultobj = Py_None;
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj;
11207 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11208 wxInputStream *result;
11209 PyObject * obj0 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "self", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11216 if (SWIG_arg_fail(1)) SWIG_fail;
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (wxInputStream *)(arg1)->GetInputStream();
11220
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 {
11225 wxPyInputStream * _ptr = NULL;
11226
11227 if (result) {
11228 _ptr = new wxPyInputStream(result);
11229 }
11230 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11231 }
11232 return resultobj;
11233 fail:
11234 return NULL;
11235 }
11236
11237
11238 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11239 PyObject *resultobj;
11240 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11241 wxInputStream *result;
11242 PyObject * obj0 = 0 ;
11243 char *kwnames[] = {
11244 (char *) "self", NULL
11245 };
11246
11247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11249 if (SWIG_arg_fail(1)) SWIG_fail;
11250 {
11251 PyThreadState* __tstate = wxPyBeginAllowThreads();
11252 result = (wxInputStream *)(arg1)->GetErrorStream();
11253
11254 wxPyEndAllowThreads(__tstate);
11255 if (PyErr_Occurred()) SWIG_fail;
11256 }
11257 {
11258 wxPyInputStream * _ptr = NULL;
11259
11260 if (result) {
11261 _ptr = new wxPyInputStream(result);
11262 }
11263 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11264 }
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj;
11273 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11274 wxOutputStream *result;
11275 PyObject * obj0 = 0 ;
11276 char *kwnames[] = {
11277 (char *) "self", NULL
11278 };
11279
11280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11282 if (SWIG_arg_fail(1)) SWIG_fail;
11283 {
11284 PyThreadState* __tstate = wxPyBeginAllowThreads();
11285 result = (wxOutputStream *)(arg1)->GetOutputStream();
11286
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11298 PyObject *resultobj;
11299 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11300 PyObject * obj0 = 0 ;
11301 char *kwnames[] = {
11302 (char *) "self", NULL
11303 };
11304
11305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11307 if (SWIG_arg_fail(1)) SWIG_fail;
11308 {
11309 PyThreadState* __tstate = wxPyBeginAllowThreads();
11310 (arg1)->CloseOutput();
11311
11312 wxPyEndAllowThreads(__tstate);
11313 if (PyErr_Occurred()) SWIG_fail;
11314 }
11315 Py_INCREF(Py_None); resultobj = Py_None;
11316 return resultobj;
11317 fail:
11318 return NULL;
11319 }
11320
11321
11322 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11323 PyObject *resultobj;
11324 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11325 bool result;
11326 PyObject * obj0 = 0 ;
11327 char *kwnames[] = {
11328 (char *) "self", NULL
11329 };
11330
11331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11333 if (SWIG_arg_fail(1)) SWIG_fail;
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11337
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 {
11342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11343 }
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11351 PyObject *resultobj;
11352 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11353 bool result;
11354 PyObject * obj0 = 0 ;
11355 char *kwnames[] = {
11356 (char *) "self", NULL
11357 };
11358
11359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11361 if (SWIG_arg_fail(1)) SWIG_fail;
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11365
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 {
11370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11371 }
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj;
11380 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11381 bool result;
11382 PyObject * obj0 = 0 ;
11383 char *kwnames[] = {
11384 (char *) "self", NULL
11385 };
11386
11387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 {
11398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11399 }
11400 return resultobj;
11401 fail:
11402 return NULL;
11403 }
11404
11405
11406 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11407 PyObject *obj;
11408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11409 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11410 Py_INCREF(obj);
11411 return Py_BuildValue((char *)"");
11412 }
11413 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj;
11415 int arg1 = (int) 0 ;
11416 int arg2 = (int) 0 ;
11417 int arg3 = (int) 0 ;
11418 wxProcessEvent *result;
11419 PyObject * obj0 = 0 ;
11420 PyObject * obj1 = 0 ;
11421 PyObject * obj2 = 0 ;
11422 char *kwnames[] = {
11423 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11424 };
11425
11426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11427 if (obj0) {
11428 {
11429 arg1 = (int)(SWIG_As_int(obj0));
11430 if (SWIG_arg_fail(1)) SWIG_fail;
11431 }
11432 }
11433 if (obj1) {
11434 {
11435 arg2 = (int)(SWIG_As_int(obj1));
11436 if (SWIG_arg_fail(2)) SWIG_fail;
11437 }
11438 }
11439 if (obj2) {
11440 {
11441 arg3 = (int)(SWIG_As_int(obj2));
11442 if (SWIG_arg_fail(3)) SWIG_fail;
11443 }
11444 }
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11448
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11460 PyObject *resultobj;
11461 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11462 int result;
11463 PyObject * obj0 = 0 ;
11464 char *kwnames[] = {
11465 (char *) "self", NULL
11466 };
11467
11468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11470 if (SWIG_arg_fail(1)) SWIG_fail;
11471 {
11472 PyThreadState* __tstate = wxPyBeginAllowThreads();
11473 result = (int)(arg1)->GetPid();
11474
11475 wxPyEndAllowThreads(__tstate);
11476 if (PyErr_Occurred()) SWIG_fail;
11477 }
11478 {
11479 resultobj = SWIG_From_int((int)(result));
11480 }
11481 return resultobj;
11482 fail:
11483 return NULL;
11484 }
11485
11486
11487 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj;
11489 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11490 int result;
11491 PyObject * obj0 = 0 ;
11492 char *kwnames[] = {
11493 (char *) "self", NULL
11494 };
11495
11496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11498 if (SWIG_arg_fail(1)) SWIG_fail;
11499 {
11500 PyThreadState* __tstate = wxPyBeginAllowThreads();
11501 result = (int)(arg1)->GetExitCode();
11502
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 resultobj = SWIG_From_int((int)(result));
11508 }
11509 return resultobj;
11510 fail:
11511 return NULL;
11512 }
11513
11514
11515 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj;
11517 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11518 int arg2 ;
11519 PyObject * obj0 = 0 ;
11520 PyObject * obj1 = 0 ;
11521 char *kwnames[] = {
11522 (char *) "self",(char *) "m_pid", NULL
11523 };
11524
11525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11527 if (SWIG_arg_fail(1)) SWIG_fail;
11528 {
11529 arg2 = (int)(SWIG_As_int(obj1));
11530 if (SWIG_arg_fail(2)) SWIG_fail;
11531 }
11532 if (arg1) (arg1)->m_pid = arg2;
11533
11534 Py_INCREF(Py_None); resultobj = Py_None;
11535 return resultobj;
11536 fail:
11537 return NULL;
11538 }
11539
11540
11541 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11542 PyObject *resultobj;
11543 wxProcessEvent *arg1 = (wxProcessEvent *) 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:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11552 if (SWIG_arg_fail(1)) SWIG_fail;
11553 result = (int) ((arg1)->m_pid);
11554
11555 {
11556 resultobj = SWIG_From_int((int)(result));
11557 }
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj;
11566 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11567 int arg2 ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "self",(char *) "m_exitcode", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 {
11578 arg2 = (int)(SWIG_As_int(obj1));
11579 if (SWIG_arg_fail(2)) SWIG_fail;
11580 }
11581 if (arg1) (arg1)->m_exitcode = arg2;
11582
11583 Py_INCREF(Py_None); resultobj = Py_None;
11584 return resultobj;
11585 fail:
11586 return NULL;
11587 }
11588
11589
11590 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11591 PyObject *resultobj;
11592 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11593 int result;
11594 PyObject * obj0 = 0 ;
11595 char *kwnames[] = {
11596 (char *) "self", NULL
11597 };
11598
11599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11601 if (SWIG_arg_fail(1)) SWIG_fail;
11602 result = (int) ((arg1)->m_exitcode);
11603
11604 {
11605 resultobj = SWIG_From_int((int)(result));
11606 }
11607 return resultobj;
11608 fail:
11609 return NULL;
11610 }
11611
11612
11613 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11614 PyObject *obj;
11615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11616 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11617 Py_INCREF(obj);
11618 return Py_BuildValue((char *)"");
11619 }
11620 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11621 PyObject *resultobj;
11622 wxString *arg1 = 0 ;
11623 int arg2 = (int) wxEXEC_ASYNC ;
11624 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11625 long result;
11626 bool temp1 = false ;
11627 PyObject * obj0 = 0 ;
11628 PyObject * obj1 = 0 ;
11629 PyObject * obj2 = 0 ;
11630 char *kwnames[] = {
11631 (char *) "command",(char *) "flags",(char *) "process", NULL
11632 };
11633
11634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11635 {
11636 arg1 = wxString_in_helper(obj0);
11637 if (arg1 == NULL) SWIG_fail;
11638 temp1 = true;
11639 }
11640 if (obj1) {
11641 {
11642 arg2 = (int)(SWIG_As_int(obj1));
11643 if (SWIG_arg_fail(2)) SWIG_fail;
11644 }
11645 }
11646 if (obj2) {
11647 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11648 if (SWIG_arg_fail(3)) SWIG_fail;
11649 }
11650 {
11651 if (!wxPyCheckForApp()) SWIG_fail;
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11654
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 resultobj = SWIG_From_long((long)(result));
11660 }
11661 {
11662 if (temp1)
11663 delete arg1;
11664 }
11665 return resultobj;
11666 fail:
11667 {
11668 if (temp1)
11669 delete arg1;
11670 }
11671 return NULL;
11672 }
11673
11674
11675 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11676 PyObject *resultobj;
11677 long arg1 ;
11678 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11679 wxKillError *arg3 = (wxKillError *) 0 ;
11680 int arg4 = (int) wxKILL_NOCHILDREN ;
11681 int result;
11682 wxKillError temp3 ;
11683 PyObject * obj0 = 0 ;
11684 PyObject * obj1 = 0 ;
11685 PyObject * obj2 = 0 ;
11686 char *kwnames[] = {
11687 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11688 };
11689
11690 {
11691 arg3 = &temp3;
11692 }
11693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11694 {
11695 arg1 = (long)(SWIG_As_long(obj0));
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 }
11698 if (obj1) {
11699 {
11700 arg2 = (wxSignal)(SWIG_As_int(obj1));
11701 if (SWIG_arg_fail(2)) SWIG_fail;
11702 }
11703 }
11704 if (obj2) {
11705 {
11706 arg4 = (int)(SWIG_As_int(obj2));
11707 if (SWIG_arg_fail(4)) SWIG_fail;
11708 }
11709 }
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11713
11714 wxPyEndAllowThreads(__tstate);
11715 if (PyErr_Occurred()) SWIG_fail;
11716 }
11717 {
11718 resultobj = SWIG_From_int((int)(result));
11719 }
11720 {
11721 PyObject* o;
11722 o = PyInt_FromLong((long) (*arg3));
11723 resultobj = t_output_helper(resultobj, o);
11724 }
11725 return resultobj;
11726 fail:
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 int arg1 = (int) wxJOYSTICK1 ;
11734 wxJoystick *result;
11735 PyObject * obj0 = 0 ;
11736 char *kwnames[] = {
11737 (char *) "joystick", NULL
11738 };
11739
11740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11741 if (obj0) {
11742 {
11743 arg1 = (int)(SWIG_As_int(obj0));
11744 if (SWIG_arg_fail(1)) SWIG_fail;
11745 }
11746 }
11747 {
11748 if (!wxPyCheckForApp()) SWIG_fail;
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 result = (wxJoystick *)new wxJoystick(arg1);
11751
11752 wxPyEndAllowThreads(__tstate);
11753 if (PyErr_Occurred()) SWIG_fail;
11754 }
11755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11763 PyObject *resultobj;
11764 wxJoystick *arg1 = (wxJoystick *) 0 ;
11765 PyObject * obj0 = 0 ;
11766 char *kwnames[] = {
11767 (char *) "self", NULL
11768 };
11769
11770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11772 if (SWIG_arg_fail(1)) SWIG_fail;
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 delete arg1;
11776
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 Py_INCREF(Py_None); resultobj = Py_None;
11781 return resultobj;
11782 fail:
11783 return NULL;
11784 }
11785
11786
11787 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11788 PyObject *resultobj;
11789 wxJoystick *arg1 = (wxJoystick *) 0 ;
11790 wxPoint result;
11791 PyObject * obj0 = 0 ;
11792 char *kwnames[] = {
11793 (char *) "self", NULL
11794 };
11795
11796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11798 if (SWIG_arg_fail(1)) SWIG_fail;
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 result = (arg1)->GetPosition();
11802
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 wxPoint * resultptr;
11808 resultptr = new wxPoint((wxPoint &)(result));
11809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11810 }
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj;
11819 wxJoystick *arg1 = (wxJoystick *) 0 ;
11820 int result;
11821 PyObject * obj0 = 0 ;
11822 char *kwnames[] = {
11823 (char *) "self", NULL
11824 };
11825
11826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11828 if (SWIG_arg_fail(1)) SWIG_fail;
11829 {
11830 PyThreadState* __tstate = wxPyBeginAllowThreads();
11831 result = (int)(arg1)->GetZPosition();
11832
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 resultobj = SWIG_From_int((int)(result));
11838 }
11839 return resultobj;
11840 fail:
11841 return NULL;
11842 }
11843
11844
11845 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11846 PyObject *resultobj;
11847 wxJoystick *arg1 = (wxJoystick *) 0 ;
11848 int result;
11849 PyObject * obj0 = 0 ;
11850 char *kwnames[] = {
11851 (char *) "self", NULL
11852 };
11853
11854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11856 if (SWIG_arg_fail(1)) SWIG_fail;
11857 {
11858 PyThreadState* __tstate = wxPyBeginAllowThreads();
11859 result = (int)(arg1)->GetButtonState();
11860
11861 wxPyEndAllowThreads(__tstate);
11862 if (PyErr_Occurred()) SWIG_fail;
11863 }
11864 {
11865 resultobj = SWIG_From_int((int)(result));
11866 }
11867 return resultobj;
11868 fail:
11869 return NULL;
11870 }
11871
11872
11873 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11874 PyObject *resultobj;
11875 wxJoystick *arg1 = (wxJoystick *) 0 ;
11876 int result;
11877 PyObject * obj0 = 0 ;
11878 char *kwnames[] = {
11879 (char *) "self", NULL
11880 };
11881
11882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11884 if (SWIG_arg_fail(1)) SWIG_fail;
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 result = (int)(arg1)->GetPOVPosition();
11888
11889 wxPyEndAllowThreads(__tstate);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 {
11893 resultobj = SWIG_From_int((int)(result));
11894 }
11895 return resultobj;
11896 fail:
11897 return NULL;
11898 }
11899
11900
11901 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11902 PyObject *resultobj;
11903 wxJoystick *arg1 = (wxJoystick *) 0 ;
11904 int result;
11905 PyObject * obj0 = 0 ;
11906 char *kwnames[] = {
11907 (char *) "self", NULL
11908 };
11909
11910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11912 if (SWIG_arg_fail(1)) SWIG_fail;
11913 {
11914 PyThreadState* __tstate = wxPyBeginAllowThreads();
11915 result = (int)(arg1)->GetPOVCTSPosition();
11916
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 {
11921 resultobj = SWIG_From_int((int)(result));
11922 }
11923 return resultobj;
11924 fail:
11925 return NULL;
11926 }
11927
11928
11929 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11930 PyObject *resultobj;
11931 wxJoystick *arg1 = (wxJoystick *) 0 ;
11932 int result;
11933 PyObject * obj0 = 0 ;
11934 char *kwnames[] = {
11935 (char *) "self", NULL
11936 };
11937
11938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11940 if (SWIG_arg_fail(1)) SWIG_fail;
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = (int)(arg1)->GetRudderPosition();
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 {
11949 resultobj = SWIG_From_int((int)(result));
11950 }
11951 return resultobj;
11952 fail:
11953 return NULL;
11954 }
11955
11956
11957 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11958 PyObject *resultobj;
11959 wxJoystick *arg1 = (wxJoystick *) 0 ;
11960 int result;
11961 PyObject * obj0 = 0 ;
11962 char *kwnames[] = {
11963 (char *) "self", NULL
11964 };
11965
11966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11968 if (SWIG_arg_fail(1)) SWIG_fail;
11969 {
11970 PyThreadState* __tstate = wxPyBeginAllowThreads();
11971 result = (int)(arg1)->GetUPosition();
11972
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 {
11977 resultobj = SWIG_From_int((int)(result));
11978 }
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11986 PyObject *resultobj;
11987 wxJoystick *arg1 = (wxJoystick *) 0 ;
11988 int result;
11989 PyObject * obj0 = 0 ;
11990 char *kwnames[] = {
11991 (char *) "self", NULL
11992 };
11993
11994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11996 if (SWIG_arg_fail(1)) SWIG_fail;
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 result = (int)(arg1)->GetVPosition();
12000
12001 wxPyEndAllowThreads(__tstate);
12002 if (PyErr_Occurred()) SWIG_fail;
12003 }
12004 {
12005 resultobj = SWIG_From_int((int)(result));
12006 }
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12014 PyObject *resultobj;
12015 wxJoystick *arg1 = (wxJoystick *) 0 ;
12016 int result;
12017 PyObject * obj0 = 0 ;
12018 char *kwnames[] = {
12019 (char *) "self", NULL
12020 };
12021
12022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12024 if (SWIG_arg_fail(1)) SWIG_fail;
12025 {
12026 PyThreadState* __tstate = wxPyBeginAllowThreads();
12027 result = (int)(arg1)->GetMovementThreshold();
12028
12029 wxPyEndAllowThreads(__tstate);
12030 if (PyErr_Occurred()) SWIG_fail;
12031 }
12032 {
12033 resultobj = SWIG_From_int((int)(result));
12034 }
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12042 PyObject *resultobj;
12043 wxJoystick *arg1 = (wxJoystick *) 0 ;
12044 int arg2 ;
12045 PyObject * obj0 = 0 ;
12046 PyObject * obj1 = 0 ;
12047 char *kwnames[] = {
12048 (char *) "self",(char *) "threshold", NULL
12049 };
12050
12051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
12052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12053 if (SWIG_arg_fail(1)) SWIG_fail;
12054 {
12055 arg2 = (int)(SWIG_As_int(obj1));
12056 if (SWIG_arg_fail(2)) SWIG_fail;
12057 }
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 (arg1)->SetMovementThreshold(arg2);
12061
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 Py_INCREF(Py_None); resultobj = Py_None;
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj;
12074 wxJoystick *arg1 = (wxJoystick *) 0 ;
12075 bool result;
12076 PyObject * obj0 = 0 ;
12077 char *kwnames[] = {
12078 (char *) "self", NULL
12079 };
12080
12081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12083 if (SWIG_arg_fail(1)) SWIG_fail;
12084 {
12085 PyThreadState* __tstate = wxPyBeginAllowThreads();
12086 result = (bool)(arg1)->IsOk();
12087
12088 wxPyEndAllowThreads(__tstate);
12089 if (PyErr_Occurred()) SWIG_fail;
12090 }
12091 {
12092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12093 }
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj;
12102 wxJoystick *arg1 = (wxJoystick *) 0 ;
12103 int result;
12104 PyObject * obj0 = 0 ;
12105 char *kwnames[] = {
12106 (char *) "self", NULL
12107 };
12108
12109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12111 if (SWIG_arg_fail(1)) SWIG_fail;
12112 {
12113 PyThreadState* __tstate = wxPyBeginAllowThreads();
12114 result = (int)(arg1)->GetNumberJoysticks();
12115
12116 wxPyEndAllowThreads(__tstate);
12117 if (PyErr_Occurred()) SWIG_fail;
12118 }
12119 {
12120 resultobj = SWIG_From_int((int)(result));
12121 }
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12129 PyObject *resultobj;
12130 wxJoystick *arg1 = (wxJoystick *) 0 ;
12131 int result;
12132 PyObject * obj0 = 0 ;
12133 char *kwnames[] = {
12134 (char *) "self", NULL
12135 };
12136
12137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12139 if (SWIG_arg_fail(1)) SWIG_fail;
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 result = (int)(arg1)->GetManufacturerId();
12143
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 {
12148 resultobj = SWIG_From_int((int)(result));
12149 }
12150 return resultobj;
12151 fail:
12152 return NULL;
12153 }
12154
12155
12156 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12157 PyObject *resultobj;
12158 wxJoystick *arg1 = (wxJoystick *) 0 ;
12159 int result;
12160 PyObject * obj0 = 0 ;
12161 char *kwnames[] = {
12162 (char *) "self", NULL
12163 };
12164
12165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12167 if (SWIG_arg_fail(1)) SWIG_fail;
12168 {
12169 PyThreadState* __tstate = wxPyBeginAllowThreads();
12170 result = (int)(arg1)->GetProductId();
12171
12172 wxPyEndAllowThreads(__tstate);
12173 if (PyErr_Occurred()) SWIG_fail;
12174 }
12175 {
12176 resultobj = SWIG_From_int((int)(result));
12177 }
12178 return resultobj;
12179 fail:
12180 return NULL;
12181 }
12182
12183
12184 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12185 PyObject *resultobj;
12186 wxJoystick *arg1 = (wxJoystick *) 0 ;
12187 wxString result;
12188 PyObject * obj0 = 0 ;
12189 char *kwnames[] = {
12190 (char *) "self", NULL
12191 };
12192
12193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12195 if (SWIG_arg_fail(1)) SWIG_fail;
12196 {
12197 PyThreadState* __tstate = wxPyBeginAllowThreads();
12198 result = (arg1)->GetProductName();
12199
12200 wxPyEndAllowThreads(__tstate);
12201 if (PyErr_Occurred()) SWIG_fail;
12202 }
12203 {
12204 #if wxUSE_UNICODE
12205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12206 #else
12207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12208 #endif
12209 }
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj;
12218 wxJoystick *arg1 = (wxJoystick *) 0 ;
12219 int result;
12220 PyObject * obj0 = 0 ;
12221 char *kwnames[] = {
12222 (char *) "self", NULL
12223 };
12224
12225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12227 if (SWIG_arg_fail(1)) SWIG_fail;
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 result = (int)(arg1)->GetXMin();
12231
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 {
12236 resultobj = SWIG_From_int((int)(result));
12237 }
12238 return resultobj;
12239 fail:
12240 return NULL;
12241 }
12242
12243
12244 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj;
12246 wxJoystick *arg1 = (wxJoystick *) 0 ;
12247 int result;
12248 PyObject * obj0 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = (int)(arg1)->GetYMin();
12259
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 {
12264 resultobj = SWIG_From_int((int)(result));
12265 }
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj;
12274 wxJoystick *arg1 = (wxJoystick *) 0 ;
12275 int result;
12276 PyObject * obj0 = 0 ;
12277 char *kwnames[] = {
12278 (char *) "self", NULL
12279 };
12280
12281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12283 if (SWIG_arg_fail(1)) SWIG_fail;
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (int)(arg1)->GetZMin();
12287
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 {
12292 resultobj = SWIG_From_int((int)(result));
12293 }
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj;
12302 wxJoystick *arg1 = (wxJoystick *) 0 ;
12303 int result;
12304 PyObject * obj0 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 result = (int)(arg1)->GetXMax();
12315
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 resultobj = SWIG_From_int((int)(result));
12321 }
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12329 PyObject *resultobj;
12330 wxJoystick *arg1 = (wxJoystick *) 0 ;
12331 int result;
12332 PyObject * obj0 = 0 ;
12333 char *kwnames[] = {
12334 (char *) "self", NULL
12335 };
12336
12337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12339 if (SWIG_arg_fail(1)) SWIG_fail;
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = (int)(arg1)->GetYMax();
12343
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = SWIG_From_int((int)(result));
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12357 PyObject *resultobj;
12358 wxJoystick *arg1 = (wxJoystick *) 0 ;
12359 int result;
12360 PyObject * obj0 = 0 ;
12361 char *kwnames[] = {
12362 (char *) "self", NULL
12363 };
12364
12365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12367 if (SWIG_arg_fail(1)) SWIG_fail;
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 result = (int)(arg1)->GetZMax();
12371
12372 wxPyEndAllowThreads(__tstate);
12373 if (PyErr_Occurred()) SWIG_fail;
12374 }
12375 {
12376 resultobj = SWIG_From_int((int)(result));
12377 }
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxJoystick *arg1 = (wxJoystick *) 0 ;
12387 int result;
12388 PyObject * obj0 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 result = (int)(arg1)->GetNumberButtons();
12399
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 {
12404 resultobj = SWIG_From_int((int)(result));
12405 }
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12413 PyObject *resultobj;
12414 wxJoystick *arg1 = (wxJoystick *) 0 ;
12415 int result;
12416 PyObject * obj0 = 0 ;
12417 char *kwnames[] = {
12418 (char *) "self", NULL
12419 };
12420
12421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12423 if (SWIG_arg_fail(1)) SWIG_fail;
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 result = (int)(arg1)->GetNumberAxes();
12427
12428 wxPyEndAllowThreads(__tstate);
12429 if (PyErr_Occurred()) SWIG_fail;
12430 }
12431 {
12432 resultobj = SWIG_From_int((int)(result));
12433 }
12434 return resultobj;
12435 fail:
12436 return NULL;
12437 }
12438
12439
12440 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12441 PyObject *resultobj;
12442 wxJoystick *arg1 = (wxJoystick *) 0 ;
12443 int result;
12444 PyObject * obj0 = 0 ;
12445 char *kwnames[] = {
12446 (char *) "self", NULL
12447 };
12448
12449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12451 if (SWIG_arg_fail(1)) SWIG_fail;
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = (int)(arg1)->GetMaxButtons();
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 resultobj = SWIG_From_int((int)(result));
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj;
12470 wxJoystick *arg1 = (wxJoystick *) 0 ;
12471 int result;
12472 PyObject * obj0 = 0 ;
12473 char *kwnames[] = {
12474 (char *) "self", NULL
12475 };
12476
12477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12479 if (SWIG_arg_fail(1)) SWIG_fail;
12480 {
12481 PyThreadState* __tstate = wxPyBeginAllowThreads();
12482 result = (int)(arg1)->GetMaxAxes();
12483
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 {
12488 resultobj = SWIG_From_int((int)(result));
12489 }
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12497 PyObject *resultobj;
12498 wxJoystick *arg1 = (wxJoystick *) 0 ;
12499 int result;
12500 PyObject * obj0 = 0 ;
12501 char *kwnames[] = {
12502 (char *) "self", NULL
12503 };
12504
12505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12507 if (SWIG_arg_fail(1)) SWIG_fail;
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 result = (int)(arg1)->GetPollingMin();
12511
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 {
12516 resultobj = SWIG_From_int((int)(result));
12517 }
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12525 PyObject *resultobj;
12526 wxJoystick *arg1 = (wxJoystick *) 0 ;
12527 int result;
12528 PyObject * obj0 = 0 ;
12529 char *kwnames[] = {
12530 (char *) "self", NULL
12531 };
12532
12533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12535 if (SWIG_arg_fail(1)) SWIG_fail;
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 result = (int)(arg1)->GetPollingMax();
12539
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 {
12544 resultobj = SWIG_From_int((int)(result));
12545 }
12546 return resultobj;
12547 fail:
12548 return NULL;
12549 }
12550
12551
12552 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12553 PyObject *resultobj;
12554 wxJoystick *arg1 = (wxJoystick *) 0 ;
12555 int result;
12556 PyObject * obj0 = 0 ;
12557 char *kwnames[] = {
12558 (char *) "self", NULL
12559 };
12560
12561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12563 if (SWIG_arg_fail(1)) SWIG_fail;
12564 {
12565 PyThreadState* __tstate = wxPyBeginAllowThreads();
12566 result = (int)(arg1)->GetRudderMin();
12567
12568 wxPyEndAllowThreads(__tstate);
12569 if (PyErr_Occurred()) SWIG_fail;
12570 }
12571 {
12572 resultobj = SWIG_From_int((int)(result));
12573 }
12574 return resultobj;
12575 fail:
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj;
12582 wxJoystick *arg1 = (wxJoystick *) 0 ;
12583 int result;
12584 PyObject * obj0 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 PyThreadState* __tstate = wxPyBeginAllowThreads();
12594 result = (int)(arg1)->GetRudderMax();
12595
12596 wxPyEndAllowThreads(__tstate);
12597 if (PyErr_Occurred()) SWIG_fail;
12598 }
12599 {
12600 resultobj = SWIG_From_int((int)(result));
12601 }
12602 return resultobj;
12603 fail:
12604 return NULL;
12605 }
12606
12607
12608 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12609 PyObject *resultobj;
12610 wxJoystick *arg1 = (wxJoystick *) 0 ;
12611 int result;
12612 PyObject * obj0 = 0 ;
12613 char *kwnames[] = {
12614 (char *) "self", NULL
12615 };
12616
12617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12619 if (SWIG_arg_fail(1)) SWIG_fail;
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 result = (int)(arg1)->GetUMin();
12623
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 {
12628 resultobj = SWIG_From_int((int)(result));
12629 }
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj;
12638 wxJoystick *arg1 = (wxJoystick *) 0 ;
12639 int result;
12640 PyObject * obj0 = 0 ;
12641 char *kwnames[] = {
12642 (char *) "self", NULL
12643 };
12644
12645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12647 if (SWIG_arg_fail(1)) SWIG_fail;
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (int)(arg1)->GetUMax();
12651
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 {
12656 resultobj = SWIG_From_int((int)(result));
12657 }
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12665 PyObject *resultobj;
12666 wxJoystick *arg1 = (wxJoystick *) 0 ;
12667 int result;
12668 PyObject * obj0 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (int)(arg1)->GetVMin();
12679
12680 wxPyEndAllowThreads(__tstate);
12681 if (PyErr_Occurred()) SWIG_fail;
12682 }
12683 {
12684 resultobj = SWIG_From_int((int)(result));
12685 }
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12693 PyObject *resultobj;
12694 wxJoystick *arg1 = (wxJoystick *) 0 ;
12695 int result;
12696 PyObject * obj0 = 0 ;
12697 char *kwnames[] = {
12698 (char *) "self", NULL
12699 };
12700
12701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12703 if (SWIG_arg_fail(1)) SWIG_fail;
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 result = (int)(arg1)->GetVMax();
12707
12708 wxPyEndAllowThreads(__tstate);
12709 if (PyErr_Occurred()) SWIG_fail;
12710 }
12711 {
12712 resultobj = SWIG_From_int((int)(result));
12713 }
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12721 PyObject *resultobj;
12722 wxJoystick *arg1 = (wxJoystick *) 0 ;
12723 bool result;
12724 PyObject * obj0 = 0 ;
12725 char *kwnames[] = {
12726 (char *) "self", NULL
12727 };
12728
12729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12731 if (SWIG_arg_fail(1)) SWIG_fail;
12732 {
12733 PyThreadState* __tstate = wxPyBeginAllowThreads();
12734 result = (bool)(arg1)->HasRudder();
12735
12736 wxPyEndAllowThreads(__tstate);
12737 if (PyErr_Occurred()) SWIG_fail;
12738 }
12739 {
12740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12741 }
12742 return resultobj;
12743 fail:
12744 return NULL;
12745 }
12746
12747
12748 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12749 PyObject *resultobj;
12750 wxJoystick *arg1 = (wxJoystick *) 0 ;
12751 bool result;
12752 PyObject * obj0 = 0 ;
12753 char *kwnames[] = {
12754 (char *) "self", NULL
12755 };
12756
12757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12759 if (SWIG_arg_fail(1)) SWIG_fail;
12760 {
12761 PyThreadState* __tstate = wxPyBeginAllowThreads();
12762 result = (bool)(arg1)->HasZ();
12763
12764 wxPyEndAllowThreads(__tstate);
12765 if (PyErr_Occurred()) SWIG_fail;
12766 }
12767 {
12768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12769 }
12770 return resultobj;
12771 fail:
12772 return NULL;
12773 }
12774
12775
12776 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12777 PyObject *resultobj;
12778 wxJoystick *arg1 = (wxJoystick *) 0 ;
12779 bool result;
12780 PyObject * obj0 = 0 ;
12781 char *kwnames[] = {
12782 (char *) "self", NULL
12783 };
12784
12785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12787 if (SWIG_arg_fail(1)) SWIG_fail;
12788 {
12789 PyThreadState* __tstate = wxPyBeginAllowThreads();
12790 result = (bool)(arg1)->HasU();
12791
12792 wxPyEndAllowThreads(__tstate);
12793 if (PyErr_Occurred()) SWIG_fail;
12794 }
12795 {
12796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12797 }
12798 return resultobj;
12799 fail:
12800 return NULL;
12801 }
12802
12803
12804 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12805 PyObject *resultobj;
12806 wxJoystick *arg1 = (wxJoystick *) 0 ;
12807 bool result;
12808 PyObject * obj0 = 0 ;
12809 char *kwnames[] = {
12810 (char *) "self", NULL
12811 };
12812
12813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12815 if (SWIG_arg_fail(1)) SWIG_fail;
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 result = (bool)(arg1)->HasV();
12819
12820 wxPyEndAllowThreads(__tstate);
12821 if (PyErr_Occurred()) SWIG_fail;
12822 }
12823 {
12824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12825 }
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12833 PyObject *resultobj;
12834 wxJoystick *arg1 = (wxJoystick *) 0 ;
12835 bool result;
12836 PyObject * obj0 = 0 ;
12837 char *kwnames[] = {
12838 (char *) "self", NULL
12839 };
12840
12841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12843 if (SWIG_arg_fail(1)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = (bool)(arg1)->HasPOV();
12847
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 {
12852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12853 }
12854 return resultobj;
12855 fail:
12856 return NULL;
12857 }
12858
12859
12860 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12861 PyObject *resultobj;
12862 wxJoystick *arg1 = (wxJoystick *) 0 ;
12863 bool result;
12864 PyObject * obj0 = 0 ;
12865 char *kwnames[] = {
12866 (char *) "self", NULL
12867 };
12868
12869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12871 if (SWIG_arg_fail(1)) SWIG_fail;
12872 {
12873 PyThreadState* __tstate = wxPyBeginAllowThreads();
12874 result = (bool)(arg1)->HasPOV4Dir();
12875
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 {
12880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12881 }
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12889 PyObject *resultobj;
12890 wxJoystick *arg1 = (wxJoystick *) 0 ;
12891 bool result;
12892 PyObject * obj0 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 PyThreadState* __tstate = wxPyBeginAllowThreads();
12902 result = (bool)(arg1)->HasPOVCTS();
12903
12904 wxPyEndAllowThreads(__tstate);
12905 if (PyErr_Occurred()) SWIG_fail;
12906 }
12907 {
12908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12909 }
12910 return resultobj;
12911 fail:
12912 return NULL;
12913 }
12914
12915
12916 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12917 PyObject *resultobj;
12918 wxJoystick *arg1 = (wxJoystick *) 0 ;
12919 wxWindow *arg2 = (wxWindow *) 0 ;
12920 int arg3 = (int) 0 ;
12921 bool result;
12922 PyObject * obj0 = 0 ;
12923 PyObject * obj1 = 0 ;
12924 PyObject * obj2 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12933 if (SWIG_arg_fail(2)) SWIG_fail;
12934 if (obj2) {
12935 {
12936 arg3 = (int)(SWIG_As_int(obj2));
12937 if (SWIG_arg_fail(3)) SWIG_fail;
12938 }
12939 }
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (bool)(arg1)->SetCapture(arg2,arg3);
12943
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 {
12948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12949 }
12950 return resultobj;
12951 fail:
12952 return NULL;
12953 }
12954
12955
12956 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12957 PyObject *resultobj;
12958 wxJoystick *arg1 = (wxJoystick *) 0 ;
12959 bool result;
12960 PyObject * obj0 = 0 ;
12961 char *kwnames[] = {
12962 (char *) "self", NULL
12963 };
12964
12965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12967 if (SWIG_arg_fail(1)) SWIG_fail;
12968 {
12969 PyThreadState* __tstate = wxPyBeginAllowThreads();
12970 result = (bool)(arg1)->ReleaseCapture();
12971
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 {
12976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12977 }
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12985 PyObject *obj;
12986 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12987 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12988 Py_INCREF(obj);
12989 return Py_BuildValue((char *)"");
12990 }
12991 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj;
12993 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12994 int arg2 = (int) 0 ;
12995 int arg3 = (int) wxJOYSTICK1 ;
12996 int arg4 = (int) 0 ;
12997 wxJoystickEvent *result;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 PyObject * obj2 = 0 ;
13001 PyObject * obj3 = 0 ;
13002 char *kwnames[] = {
13003 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13004 };
13005
13006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13007 if (obj0) {
13008 {
13009 arg1 = (wxEventType)(SWIG_As_int(obj0));
13010 if (SWIG_arg_fail(1)) SWIG_fail;
13011 }
13012 }
13013 if (obj1) {
13014 {
13015 arg2 = (int)(SWIG_As_int(obj1));
13016 if (SWIG_arg_fail(2)) SWIG_fail;
13017 }
13018 }
13019 if (obj2) {
13020 {
13021 arg3 = (int)(SWIG_As_int(obj2));
13022 if (SWIG_arg_fail(3)) SWIG_fail;
13023 }
13024 }
13025 if (obj3) {
13026 {
13027 arg4 = (int)(SWIG_As_int(obj3));
13028 if (SWIG_arg_fail(4)) SWIG_fail;
13029 }
13030 }
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13034
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13048 wxPoint result;
13049 PyObject * obj0 = 0 ;
13050 char *kwnames[] = {
13051 (char *) "self", NULL
13052 };
13053
13054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13056 if (SWIG_arg_fail(1)) SWIG_fail;
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13060
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 {
13065 wxPoint * resultptr;
13066 resultptr = new wxPoint((wxPoint &)(result));
13067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13068 }
13069 return resultobj;
13070 fail:
13071 return NULL;
13072 }
13073
13074
13075 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13076 PyObject *resultobj;
13077 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13078 int result;
13079 PyObject * obj0 = 0 ;
13080 char *kwnames[] = {
13081 (char *) "self", NULL
13082 };
13083
13084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13086 if (SWIG_arg_fail(1)) SWIG_fail;
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13090
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 {
13095 resultobj = SWIG_From_int((int)(result));
13096 }
13097 return resultobj;
13098 fail:
13099 return NULL;
13100 }
13101
13102
13103 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj;
13105 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13106 int result;
13107 PyObject * obj0 = 0 ;
13108 char *kwnames[] = {
13109 (char *) "self", NULL
13110 };
13111
13112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13114 if (SWIG_arg_fail(1)) SWIG_fail;
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13118
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 {
13123 resultobj = SWIG_From_int((int)(result));
13124 }
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj;
13133 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13134 int result;
13135 PyObject * obj0 = 0 ;
13136 char *kwnames[] = {
13137 (char *) "self", NULL
13138 };
13139
13140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13142 if (SWIG_arg_fail(1)) SWIG_fail;
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 {
13151 resultobj = SWIG_From_int((int)(result));
13152 }
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj;
13161 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13162 int result;
13163 PyObject * obj0 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "self", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13170 if (SWIG_arg_fail(1)) SWIG_fail;
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = SWIG_From_int((int)(result));
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13190 int arg2 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 char *kwnames[] = {
13194 (char *) "self",(char *) "stick", NULL
13195 };
13196
13197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13199 if (SWIG_arg_fail(1)) SWIG_fail;
13200 {
13201 arg2 = (int)(SWIG_As_int(obj1));
13202 if (SWIG_arg_fail(2)) SWIG_fail;
13203 }
13204 {
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 (arg1)->SetJoystick(arg2);
13207
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 Py_INCREF(Py_None); resultobj = Py_None;
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj;
13220 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13221 int arg2 ;
13222 PyObject * obj0 = 0 ;
13223 PyObject * obj1 = 0 ;
13224 char *kwnames[] = {
13225 (char *) "self",(char *) "state", NULL
13226 };
13227
13228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13230 if (SWIG_arg_fail(1)) SWIG_fail;
13231 {
13232 arg2 = (int)(SWIG_As_int(obj1));
13233 if (SWIG_arg_fail(2)) SWIG_fail;
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 (arg1)->SetButtonState(arg2);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 Py_INCREF(Py_None); resultobj = Py_None;
13243 return resultobj;
13244 fail:
13245 return NULL;
13246 }
13247
13248
13249 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13250 PyObject *resultobj;
13251 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13252 int arg2 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 char *kwnames[] = {
13256 (char *) "self",(char *) "change", NULL
13257 };
13258
13259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13261 if (SWIG_arg_fail(1)) SWIG_fail;
13262 {
13263 arg2 = (int)(SWIG_As_int(obj1));
13264 if (SWIG_arg_fail(2)) SWIG_fail;
13265 }
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 (arg1)->SetButtonChange(arg2);
13269
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 Py_INCREF(Py_None); resultobj = Py_None;
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13283 wxPoint *arg2 = 0 ;
13284 wxPoint temp2 ;
13285 PyObject * obj0 = 0 ;
13286 PyObject * obj1 = 0 ;
13287 char *kwnames[] = {
13288 (char *) "self",(char *) "pos", NULL
13289 };
13290
13291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13293 if (SWIG_arg_fail(1)) SWIG_fail;
13294 {
13295 arg2 = &temp2;
13296 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 (arg1)->SetPosition((wxPoint const &)*arg2);
13301
13302 wxPyEndAllowThreads(__tstate);
13303 if (PyErr_Occurred()) SWIG_fail;
13304 }
13305 Py_INCREF(Py_None); resultobj = Py_None;
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13313 PyObject *resultobj;
13314 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13315 int arg2 ;
13316 PyObject * obj0 = 0 ;
13317 PyObject * obj1 = 0 ;
13318 char *kwnames[] = {
13319 (char *) "self",(char *) "zPos", NULL
13320 };
13321
13322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13324 if (SWIG_arg_fail(1)) SWIG_fail;
13325 {
13326 arg2 = (int)(SWIG_As_int(obj1));
13327 if (SWIG_arg_fail(2)) SWIG_fail;
13328 }
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 (arg1)->SetZPosition(arg2);
13332
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 Py_INCREF(Py_None); resultobj = Py_None;
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13344 PyObject *resultobj;
13345 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13346 bool result;
13347 PyObject * obj0 = 0 ;
13348 char *kwnames[] = {
13349 (char *) "self", NULL
13350 };
13351
13352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13354 if (SWIG_arg_fail(1)) SWIG_fail;
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13358
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 {
13363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13364 }
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13374 bool result;
13375 PyObject * obj0 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "self", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13382 if (SWIG_arg_fail(1)) SWIG_fail;
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13386
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 {
13391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13392 }
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13400 PyObject *resultobj;
13401 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13402 bool result;
13403 PyObject * obj0 = 0 ;
13404 char *kwnames[] = {
13405 (char *) "self", NULL
13406 };
13407
13408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13410 if (SWIG_arg_fail(1)) SWIG_fail;
13411 {
13412 PyThreadState* __tstate = wxPyBeginAllowThreads();
13413 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13414
13415 wxPyEndAllowThreads(__tstate);
13416 if (PyErr_Occurred()) SWIG_fail;
13417 }
13418 {
13419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13420 }
13421 return resultobj;
13422 fail:
13423 return NULL;
13424 }
13425
13426
13427 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13428 PyObject *resultobj;
13429 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13430 int arg2 = (int) wxJOY_BUTTON_ANY ;
13431 bool result;
13432 PyObject * obj0 = 0 ;
13433 PyObject * obj1 = 0 ;
13434 char *kwnames[] = {
13435 (char *) "self",(char *) "but", NULL
13436 };
13437
13438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13440 if (SWIG_arg_fail(1)) SWIG_fail;
13441 if (obj1) {
13442 {
13443 arg2 = (int)(SWIG_As_int(obj1));
13444 if (SWIG_arg_fail(2)) SWIG_fail;
13445 }
13446 }
13447 {
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13450
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 {
13455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13456 }
13457 return resultobj;
13458 fail:
13459 return NULL;
13460 }
13461
13462
13463 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13464 PyObject *resultobj;
13465 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13466 int arg2 = (int) wxJOY_BUTTON_ANY ;
13467 bool result;
13468 PyObject * obj0 = 0 ;
13469 PyObject * obj1 = 0 ;
13470 char *kwnames[] = {
13471 (char *) "self",(char *) "but", NULL
13472 };
13473
13474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13476 if (SWIG_arg_fail(1)) SWIG_fail;
13477 if (obj1) {
13478 {
13479 arg2 = (int)(SWIG_As_int(obj1));
13480 if (SWIG_arg_fail(2)) SWIG_fail;
13481 }
13482 }
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13486
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 {
13491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13492 }
13493 return resultobj;
13494 fail:
13495 return NULL;
13496 }
13497
13498
13499 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13500 PyObject *resultobj;
13501 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13502 int arg2 = (int) wxJOY_BUTTON_ANY ;
13503 bool result;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 char *kwnames[] = {
13507 (char *) "self",(char *) "but", NULL
13508 };
13509
13510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13512 if (SWIG_arg_fail(1)) SWIG_fail;
13513 if (obj1) {
13514 {
13515 arg2 = (int)(SWIG_As_int(obj1));
13516 if (SWIG_arg_fail(2)) SWIG_fail;
13517 }
13518 }
13519 {
13520 PyThreadState* __tstate = wxPyBeginAllowThreads();
13521 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13522
13523 wxPyEndAllowThreads(__tstate);
13524 if (PyErr_Occurred()) SWIG_fail;
13525 }
13526 {
13527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13528 }
13529 return resultobj;
13530 fail:
13531 return NULL;
13532 }
13533
13534
13535 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13536 PyObject *obj;
13537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13538 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13539 Py_INCREF(obj);
13540 return Py_BuildValue((char *)"");
13541 }
13542 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13543 PyObject *resultobj;
13544 wxString const &arg1_defvalue = wxPyEmptyString ;
13545 wxString *arg1 = (wxString *) &arg1_defvalue ;
13546 wxSound *result;
13547 bool temp1 = false ;
13548 PyObject * obj0 = 0 ;
13549 char *kwnames[] = {
13550 (char *) "fileName", NULL
13551 };
13552
13553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13554 if (obj0) {
13555 {
13556 arg1 = wxString_in_helper(obj0);
13557 if (arg1 == NULL) SWIG_fail;
13558 temp1 = true;
13559 }
13560 }
13561 {
13562 if (!wxPyCheckForApp()) SWIG_fail;
13563 PyThreadState* __tstate = wxPyBeginAllowThreads();
13564 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13565
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13570 {
13571 if (temp1)
13572 delete arg1;
13573 }
13574 return resultobj;
13575 fail:
13576 {
13577 if (temp1)
13578 delete arg1;
13579 }
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj;
13586 PyObject *arg1 = (PyObject *) 0 ;
13587 wxSound *result;
13588 PyObject * obj0 = 0 ;
13589 char *kwnames[] = {
13590 (char *) "data", NULL
13591 };
13592
13593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13594 arg1 = obj0;
13595 {
13596 if (!wxPyCheckForApp()) SWIG_fail;
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (wxSound *)new_wxSound(arg1);
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13604 return resultobj;
13605 fail:
13606 return NULL;
13607 }
13608
13609
13610 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13611 PyObject *resultobj;
13612 wxSound *arg1 = (wxSound *) 0 ;
13613 PyObject * obj0 = 0 ;
13614 char *kwnames[] = {
13615 (char *) "self", NULL
13616 };
13617
13618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13620 if (SWIG_arg_fail(1)) SWIG_fail;
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 delete arg1;
13624
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 Py_INCREF(Py_None); resultobj = Py_None;
13629 return resultobj;
13630 fail:
13631 return NULL;
13632 }
13633
13634
13635 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13636 PyObject *resultobj;
13637 wxSound *arg1 = (wxSound *) 0 ;
13638 wxString *arg2 = 0 ;
13639 bool result;
13640 bool temp2 = false ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 char *kwnames[] = {
13644 (char *) "self",(char *) "fileName", NULL
13645 };
13646
13647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13649 if (SWIG_arg_fail(1)) SWIG_fail;
13650 {
13651 arg2 = wxString_in_helper(obj1);
13652 if (arg2 == NULL) SWIG_fail;
13653 temp2 = true;
13654 }
13655 {
13656 PyThreadState* __tstate = wxPyBeginAllowThreads();
13657 result = (bool)(arg1)->Create((wxString const &)*arg2);
13658
13659 wxPyEndAllowThreads(__tstate);
13660 if (PyErr_Occurred()) SWIG_fail;
13661 }
13662 {
13663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13664 }
13665 {
13666 if (temp2)
13667 delete arg2;
13668 }
13669 return resultobj;
13670 fail:
13671 {
13672 if (temp2)
13673 delete arg2;
13674 }
13675 return NULL;
13676 }
13677
13678
13679 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13680 PyObject *resultobj;
13681 wxSound *arg1 = (wxSound *) 0 ;
13682 PyObject *arg2 = (PyObject *) 0 ;
13683 bool result;
13684 PyObject * obj0 = 0 ;
13685 PyObject * obj1 = 0 ;
13686 char *kwnames[] = {
13687 (char *) "self",(char *) "data", NULL
13688 };
13689
13690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13692 if (SWIG_arg_fail(1)) SWIG_fail;
13693 arg2 = obj1;
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 result = (bool)wxSound_CreateFromData(arg1,arg2);
13697
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 {
13702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13703 }
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13711 PyObject *resultobj;
13712 wxSound *arg1 = (wxSound *) 0 ;
13713 bool result;
13714 PyObject * obj0 = 0 ;
13715 char *kwnames[] = {
13716 (char *) "self", NULL
13717 };
13718
13719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13721 if (SWIG_arg_fail(1)) SWIG_fail;
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 result = (bool)(arg1)->IsOk();
13725
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 {
13730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13731 }
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13739 PyObject *resultobj;
13740 wxSound *arg1 = (wxSound *) 0 ;
13741 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13742 bool result;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 char *kwnames[] = {
13746 (char *) "self",(char *) "flags", NULL
13747 };
13748
13749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13751 if (SWIG_arg_fail(1)) SWIG_fail;
13752 if (obj1) {
13753 {
13754 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13755 if (SWIG_arg_fail(2)) SWIG_fail;
13756 }
13757 }
13758 {
13759 if (!wxPyCheckForApp()) SWIG_fail;
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 result = (bool)((wxSound const *)arg1)->Play(arg2);
13762
13763 wxPyEndAllowThreads(__tstate);
13764 if (PyErr_Occurred()) SWIG_fail;
13765 }
13766 {
13767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13768 }
13769 return resultobj;
13770 fail:
13771 return NULL;
13772 }
13773
13774
13775 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13776 PyObject *resultobj;
13777 wxString *arg1 = 0 ;
13778 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13779 bool result;
13780 bool temp1 = false ;
13781 PyObject * obj0 = 0 ;
13782 PyObject * obj1 = 0 ;
13783 char *kwnames[] = {
13784 (char *) "filename",(char *) "flags", NULL
13785 };
13786
13787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13788 {
13789 arg1 = wxString_in_helper(obj0);
13790 if (arg1 == NULL) SWIG_fail;
13791 temp1 = true;
13792 }
13793 if (obj1) {
13794 {
13795 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13796 if (SWIG_arg_fail(2)) SWIG_fail;
13797 }
13798 }
13799 {
13800 if (!wxPyCheckForApp()) SWIG_fail;
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13803
13804 wxPyEndAllowThreads(__tstate);
13805 if (PyErr_Occurred()) SWIG_fail;
13806 }
13807 {
13808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13809 }
13810 {
13811 if (temp1)
13812 delete arg1;
13813 }
13814 return resultobj;
13815 fail:
13816 {
13817 if (temp1)
13818 delete arg1;
13819 }
13820 return NULL;
13821 }
13822
13823
13824 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13825 PyObject *resultobj;
13826 char *kwnames[] = {
13827 NULL
13828 };
13829
13830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13831 {
13832 if (!wxPyCheckForApp()) SWIG_fail;
13833 PyThreadState* __tstate = wxPyBeginAllowThreads();
13834 wxSound::Stop();
13835
13836 wxPyEndAllowThreads(__tstate);
13837 if (PyErr_Occurred()) SWIG_fail;
13838 }
13839 Py_INCREF(Py_None); resultobj = Py_None;
13840 return resultobj;
13841 fail:
13842 return NULL;
13843 }
13844
13845
13846 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13847 PyObject *obj;
13848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13849 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13850 Py_INCREF(obj);
13851 return Py_BuildValue((char *)"");
13852 }
13853 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13854 PyObject *resultobj;
13855 wxString *arg1 = 0 ;
13856 wxString *arg2 = 0 ;
13857 wxString *arg3 = 0 ;
13858 wxString *arg4 = 0 ;
13859 wxFileTypeInfo *result;
13860 bool temp1 = false ;
13861 bool temp2 = false ;
13862 bool temp3 = false ;
13863 bool temp4 = false ;
13864 PyObject * obj0 = 0 ;
13865 PyObject * obj1 = 0 ;
13866 PyObject * obj2 = 0 ;
13867 PyObject * obj3 = 0 ;
13868 char *kwnames[] = {
13869 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13870 };
13871
13872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13873 {
13874 arg1 = wxString_in_helper(obj0);
13875 if (arg1 == NULL) SWIG_fail;
13876 temp1 = true;
13877 }
13878 {
13879 arg2 = wxString_in_helper(obj1);
13880 if (arg2 == NULL) SWIG_fail;
13881 temp2 = true;
13882 }
13883 {
13884 arg3 = wxString_in_helper(obj2);
13885 if (arg3 == NULL) SWIG_fail;
13886 temp3 = true;
13887 }
13888 {
13889 arg4 = wxString_in_helper(obj3);
13890 if (arg4 == NULL) SWIG_fail;
13891 temp4 = true;
13892 }
13893 {
13894 PyThreadState* __tstate = wxPyBeginAllowThreads();
13895 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13896
13897 wxPyEndAllowThreads(__tstate);
13898 if (PyErr_Occurred()) SWIG_fail;
13899 }
13900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13901 {
13902 if (temp1)
13903 delete arg1;
13904 }
13905 {
13906 if (temp2)
13907 delete arg2;
13908 }
13909 {
13910 if (temp3)
13911 delete arg3;
13912 }
13913 {
13914 if (temp4)
13915 delete arg4;
13916 }
13917 return resultobj;
13918 fail:
13919 {
13920 if (temp1)
13921 delete arg1;
13922 }
13923 {
13924 if (temp2)
13925 delete arg2;
13926 }
13927 {
13928 if (temp3)
13929 delete arg3;
13930 }
13931 {
13932 if (temp4)
13933 delete arg4;
13934 }
13935 return NULL;
13936 }
13937
13938
13939 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13940 PyObject *resultobj;
13941 wxArrayString *arg1 = 0 ;
13942 wxFileTypeInfo *result;
13943 bool temp1 = false ;
13944 PyObject * obj0 = 0 ;
13945 char *kwnames[] = {
13946 (char *) "sArray", NULL
13947 };
13948
13949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13950 {
13951 if (! PySequence_Check(obj0)) {
13952 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13953 SWIG_fail;
13954 }
13955 arg1 = new wxArrayString;
13956 temp1 = true;
13957 int i, len=PySequence_Length(obj0);
13958 for (i=0; i<len; i++) {
13959 PyObject* item = PySequence_GetItem(obj0, i);
13960 wxString* s = wxString_in_helper(item);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 arg1->Add(*s);
13963 delete s;
13964 Py_DECREF(item);
13965 }
13966 }
13967 {
13968 PyThreadState* __tstate = wxPyBeginAllowThreads();
13969 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13970
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13975 {
13976 if (temp1) delete arg1;
13977 }
13978 return resultobj;
13979 fail:
13980 {
13981 if (temp1) delete arg1;
13982 }
13983 return NULL;
13984 }
13985
13986
13987 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13988 PyObject *resultobj;
13989 wxFileTypeInfo *result;
13990 char *kwnames[] = {
13991 NULL
13992 };
13993
13994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13998
13999 wxPyEndAllowThreads(__tstate);
14000 if (PyErr_Occurred()) SWIG_fail;
14001 }
14002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14003 return resultobj;
14004 fail:
14005 return NULL;
14006 }
14007
14008
14009 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14010 PyObject *resultobj;
14011 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14012 bool result;
14013 PyObject * obj0 = 0 ;
14014 char *kwnames[] = {
14015 (char *) "self", NULL
14016 };
14017
14018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14020 if (SWIG_arg_fail(1)) SWIG_fail;
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 {
14029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14030 }
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14038 PyObject *resultobj;
14039 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14040 wxString *arg2 = 0 ;
14041 int arg3 = (int) 0 ;
14042 bool temp2 = false ;
14043 PyObject * obj0 = 0 ;
14044 PyObject * obj1 = 0 ;
14045 PyObject * obj2 = 0 ;
14046 char *kwnames[] = {
14047 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14048 };
14049
14050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14052 if (SWIG_arg_fail(1)) SWIG_fail;
14053 {
14054 arg2 = wxString_in_helper(obj1);
14055 if (arg2 == NULL) SWIG_fail;
14056 temp2 = true;
14057 }
14058 if (obj2) {
14059 {
14060 arg3 = (int)(SWIG_As_int(obj2));
14061 if (SWIG_arg_fail(3)) SWIG_fail;
14062 }
14063 }
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14067
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 Py_INCREF(Py_None); resultobj = Py_None;
14072 {
14073 if (temp2)
14074 delete arg2;
14075 }
14076 return resultobj;
14077 fail:
14078 {
14079 if (temp2)
14080 delete arg2;
14081 }
14082 return NULL;
14083 }
14084
14085
14086 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj;
14088 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14089 wxString *arg2 = 0 ;
14090 bool temp2 = false ;
14091 PyObject * obj0 = 0 ;
14092 PyObject * obj1 = 0 ;
14093 char *kwnames[] = {
14094 (char *) "self",(char *) "shortDesc", NULL
14095 };
14096
14097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14099 if (SWIG_arg_fail(1)) SWIG_fail;
14100 {
14101 arg2 = wxString_in_helper(obj1);
14102 if (arg2 == NULL) SWIG_fail;
14103 temp2 = true;
14104 }
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 (arg1)->SetShortDesc((wxString const &)*arg2);
14108
14109 wxPyEndAllowThreads(__tstate);
14110 if (PyErr_Occurred()) SWIG_fail;
14111 }
14112 Py_INCREF(Py_None); resultobj = Py_None;
14113 {
14114 if (temp2)
14115 delete arg2;
14116 }
14117 return resultobj;
14118 fail:
14119 {
14120 if (temp2)
14121 delete arg2;
14122 }
14123 return NULL;
14124 }
14125
14126
14127 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14128 PyObject *resultobj;
14129 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14130 wxString *result;
14131 PyObject * obj0 = 0 ;
14132 char *kwnames[] = {
14133 (char *) "self", NULL
14134 };
14135
14136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14138 if (SWIG_arg_fail(1)) SWIG_fail;
14139 {
14140 PyThreadState* __tstate = wxPyBeginAllowThreads();
14141 {
14142 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14143 result = (wxString *) &_result_ref;
14144 }
14145
14146 wxPyEndAllowThreads(__tstate);
14147 if (PyErr_Occurred()) SWIG_fail;
14148 }
14149 {
14150 #if wxUSE_UNICODE
14151 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14152 #else
14153 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14154 #endif
14155 }
14156 return resultobj;
14157 fail:
14158 return NULL;
14159 }
14160
14161
14162 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14163 PyObject *resultobj;
14164 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14165 wxString *result;
14166 PyObject * obj0 = 0 ;
14167 char *kwnames[] = {
14168 (char *) "self", NULL
14169 };
14170
14171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14173 if (SWIG_arg_fail(1)) SWIG_fail;
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 {
14177 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14178 result = (wxString *) &_result_ref;
14179 }
14180
14181 wxPyEndAllowThreads(__tstate);
14182 if (PyErr_Occurred()) SWIG_fail;
14183 }
14184 {
14185 #if wxUSE_UNICODE
14186 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14187 #else
14188 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14189 #endif
14190 }
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj;
14199 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14200 wxString *result;
14201 PyObject * obj0 = 0 ;
14202 char *kwnames[] = {
14203 (char *) "self", NULL
14204 };
14205
14206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14208 if (SWIG_arg_fail(1)) SWIG_fail;
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 {
14212 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14213 result = (wxString *) &_result_ref;
14214 }
14215
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 {
14220 #if wxUSE_UNICODE
14221 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14222 #else
14223 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14224 #endif
14225 }
14226 return resultobj;
14227 fail:
14228 return NULL;
14229 }
14230
14231
14232 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14233 PyObject *resultobj;
14234 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14235 wxString *result;
14236 PyObject * obj0 = 0 ;
14237 char *kwnames[] = {
14238 (char *) "self", NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 {
14245 PyThreadState* __tstate = wxPyBeginAllowThreads();
14246 {
14247 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14248 result = (wxString *) &_result_ref;
14249 }
14250
14251 wxPyEndAllowThreads(__tstate);
14252 if (PyErr_Occurred()) SWIG_fail;
14253 }
14254 {
14255 #if wxUSE_UNICODE
14256 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14257 #else
14258 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14259 #endif
14260 }
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14268 PyObject *resultobj;
14269 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14270 wxString *result;
14271 PyObject * obj0 = 0 ;
14272 char *kwnames[] = {
14273 (char *) "self", NULL
14274 };
14275
14276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14278 if (SWIG_arg_fail(1)) SWIG_fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 {
14282 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14283 result = (wxString *) &_result_ref;
14284 }
14285
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 {
14290 #if wxUSE_UNICODE
14291 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14292 #else
14293 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14294 #endif
14295 }
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj;
14304 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14305 wxArrayString *result;
14306 PyObject * obj0 = 0 ;
14307 char *kwnames[] = {
14308 (char *) "self", NULL
14309 };
14310
14311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14313 if (SWIG_arg_fail(1)) SWIG_fail;
14314 {
14315 PyThreadState* __tstate = wxPyBeginAllowThreads();
14316 {
14317 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14318 result = (wxArrayString *) &_result_ref;
14319 }
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 {
14325 resultobj = wxArrayString2PyList_helper(*result);
14326 }
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14334 PyObject *resultobj;
14335 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14336 int result;
14337 PyObject * obj0 = 0 ;
14338 char *kwnames[] = {
14339 (char *) "self", NULL
14340 };
14341
14342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14344 if (SWIG_arg_fail(1)) SWIG_fail;
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14348
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 {
14353 resultobj = SWIG_From_int((int)(result));
14354 }
14355 return resultobj;
14356 fail:
14357 return NULL;
14358 }
14359
14360
14361 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14362 PyObject *resultobj;
14363 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14364 wxString *result;
14365 PyObject * obj0 = 0 ;
14366 char *kwnames[] = {
14367 (char *) "self", NULL
14368 };
14369
14370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14372 if (SWIG_arg_fail(1)) SWIG_fail;
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 {
14376 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14377 result = (wxString *) &_result_ref;
14378 }
14379
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 {
14384 #if wxUSE_UNICODE
14385 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14386 #else
14387 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14388 #endif
14389 }
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14397 PyObject *resultobj;
14398 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14399 int result;
14400 PyObject * obj0 = 0 ;
14401 char *kwnames[] = {
14402 (char *) "self", NULL
14403 };
14404
14405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14407 if (SWIG_arg_fail(1)) SWIG_fail;
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14411
14412 wxPyEndAllowThreads(__tstate);
14413 if (PyErr_Occurred()) SWIG_fail;
14414 }
14415 {
14416 resultobj = SWIG_From_int((int)(result));
14417 }
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14425 PyObject *obj;
14426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14427 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14428 Py_INCREF(obj);
14429 return Py_BuildValue((char *)"");
14430 }
14431 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj;
14433 wxFileTypeInfo *arg1 = 0 ;
14434 wxFileType *result;
14435 PyObject * obj0 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "ftInfo", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14441 {
14442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14443 if (SWIG_arg_fail(1)) SWIG_fail;
14444 if (arg1 == NULL) {
14445 SWIG_null_ref("wxFileTypeInfo");
14446 }
14447 if (SWIG_arg_fail(1)) SWIG_fail;
14448 }
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14457 return resultobj;
14458 fail:
14459 return NULL;
14460 }
14461
14462
14463 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14464 PyObject *resultobj;
14465 wxFileType *arg1 = (wxFileType *) 0 ;
14466 PyObject * obj0 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "self", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14473 if (SWIG_arg_fail(1)) SWIG_fail;
14474 {
14475 PyThreadState* __tstate = wxPyBeginAllowThreads();
14476 delete arg1;
14477
14478 wxPyEndAllowThreads(__tstate);
14479 if (PyErr_Occurred()) SWIG_fail;
14480 }
14481 Py_INCREF(Py_None); resultobj = Py_None;
14482 return resultobj;
14483 fail:
14484 return NULL;
14485 }
14486
14487
14488 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14489 PyObject *resultobj;
14490 wxFileType *arg1 = (wxFileType *) 0 ;
14491 PyObject *result;
14492 PyObject * obj0 = 0 ;
14493 char *kwnames[] = {
14494 (char *) "self", NULL
14495 };
14496
14497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14499 if (SWIG_arg_fail(1)) SWIG_fail;
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 result = (PyObject *)wxFileType_GetMimeType(arg1);
14503
14504 wxPyEndAllowThreads(__tstate);
14505 if (PyErr_Occurred()) SWIG_fail;
14506 }
14507 resultobj = result;
14508 return resultobj;
14509 fail:
14510 return NULL;
14511 }
14512
14513
14514 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14515 PyObject *resultobj;
14516 wxFileType *arg1 = (wxFileType *) 0 ;
14517 PyObject *result;
14518 PyObject * obj0 = 0 ;
14519 char *kwnames[] = {
14520 (char *) "self", NULL
14521 };
14522
14523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14525 if (SWIG_arg_fail(1)) SWIG_fail;
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14529
14530 wxPyEndAllowThreads(__tstate);
14531 if (PyErr_Occurred()) SWIG_fail;
14532 }
14533 resultobj = result;
14534 return resultobj;
14535 fail:
14536 return NULL;
14537 }
14538
14539
14540 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14541 PyObject *resultobj;
14542 wxFileType *arg1 = (wxFileType *) 0 ;
14543 PyObject *result;
14544 PyObject * obj0 = 0 ;
14545 char *kwnames[] = {
14546 (char *) "self", NULL
14547 };
14548
14549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14551 if (SWIG_arg_fail(1)) SWIG_fail;
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 result = (PyObject *)wxFileType_GetExtensions(arg1);
14555
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 resultobj = result;
14560 return resultobj;
14561 fail:
14562 return NULL;
14563 }
14564
14565
14566 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj;
14568 wxFileType *arg1 = (wxFileType *) 0 ;
14569 wxIcon *result;
14570 PyObject * obj0 = 0 ;
14571 char *kwnames[] = {
14572 (char *) "self", NULL
14573 };
14574
14575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14577 if (SWIG_arg_fail(1)) SWIG_fail;
14578 {
14579 PyThreadState* __tstate = wxPyBeginAllowThreads();
14580 result = (wxIcon *)wxFileType_GetIcon(arg1);
14581
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj;
14594 wxFileType *arg1 = (wxFileType *) 0 ;
14595 PyObject *result;
14596 PyObject * obj0 = 0 ;
14597 char *kwnames[] = {
14598 (char *) "self", NULL
14599 };
14600
14601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14603 if (SWIG_arg_fail(1)) SWIG_fail;
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14607
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 resultobj = result;
14612 return resultobj;
14613 fail:
14614 return NULL;
14615 }
14616
14617
14618 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14619 PyObject *resultobj;
14620 wxFileType *arg1 = (wxFileType *) 0 ;
14621 PyObject *result;
14622 PyObject * obj0 = 0 ;
14623 char *kwnames[] = {
14624 (char *) "self", NULL
14625 };
14626
14627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14629 if (SWIG_arg_fail(1)) SWIG_fail;
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 result = (PyObject *)wxFileType_GetDescription(arg1);
14633
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 resultobj = result;
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj;
14646 wxFileType *arg1 = (wxFileType *) 0 ;
14647 wxString *arg2 = 0 ;
14648 wxString const &arg3_defvalue = wxPyEmptyString ;
14649 wxString *arg3 = (wxString *) &arg3_defvalue ;
14650 PyObject *result;
14651 bool temp2 = false ;
14652 bool temp3 = false ;
14653 PyObject * obj0 = 0 ;
14654 PyObject * obj1 = 0 ;
14655 PyObject * obj2 = 0 ;
14656 char *kwnames[] = {
14657 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14658 };
14659
14660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(1)) SWIG_fail;
14663 {
14664 arg2 = wxString_in_helper(obj1);
14665 if (arg2 == NULL) SWIG_fail;
14666 temp2 = true;
14667 }
14668 if (obj2) {
14669 {
14670 arg3 = wxString_in_helper(obj2);
14671 if (arg3 == NULL) SWIG_fail;
14672 temp3 = true;
14673 }
14674 }
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14678
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 resultobj = result;
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 {
14688 if (temp3)
14689 delete arg3;
14690 }
14691 return resultobj;
14692 fail:
14693 {
14694 if (temp2)
14695 delete arg2;
14696 }
14697 {
14698 if (temp3)
14699 delete arg3;
14700 }
14701 return NULL;
14702 }
14703
14704
14705 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14706 PyObject *resultobj;
14707 wxFileType *arg1 = (wxFileType *) 0 ;
14708 wxString *arg2 = 0 ;
14709 wxString const &arg3_defvalue = wxPyEmptyString ;
14710 wxString *arg3 = (wxString *) &arg3_defvalue ;
14711 PyObject *result;
14712 bool temp2 = false ;
14713 bool temp3 = false ;
14714 PyObject * obj0 = 0 ;
14715 PyObject * obj1 = 0 ;
14716 PyObject * obj2 = 0 ;
14717 char *kwnames[] = {
14718 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14719 };
14720
14721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14723 if (SWIG_arg_fail(1)) SWIG_fail;
14724 {
14725 arg2 = wxString_in_helper(obj1);
14726 if (arg2 == NULL) SWIG_fail;
14727 temp2 = true;
14728 }
14729 if (obj2) {
14730 {
14731 arg3 = wxString_in_helper(obj2);
14732 if (arg3 == NULL) SWIG_fail;
14733 temp3 = true;
14734 }
14735 }
14736 {
14737 PyThreadState* __tstate = wxPyBeginAllowThreads();
14738 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14739
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 resultobj = result;
14744 {
14745 if (temp2)
14746 delete arg2;
14747 }
14748 {
14749 if (temp3)
14750 delete arg3;
14751 }
14752 return resultobj;
14753 fail:
14754 {
14755 if (temp2)
14756 delete arg2;
14757 }
14758 {
14759 if (temp3)
14760 delete arg3;
14761 }
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxFileType *arg1 = (wxFileType *) 0 ;
14769 wxString *arg2 = 0 ;
14770 wxString const &arg3_defvalue = wxPyEmptyString ;
14771 wxString *arg3 = (wxString *) &arg3_defvalue ;
14772 PyObject *result;
14773 bool temp2 = false ;
14774 bool temp3 = false ;
14775 PyObject * obj0 = 0 ;
14776 PyObject * obj1 = 0 ;
14777 PyObject * obj2 = 0 ;
14778 char *kwnames[] = {
14779 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14780 };
14781
14782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14784 if (SWIG_arg_fail(1)) SWIG_fail;
14785 {
14786 arg2 = wxString_in_helper(obj1);
14787 if (arg2 == NULL) SWIG_fail;
14788 temp2 = true;
14789 }
14790 if (obj2) {
14791 {
14792 arg3 = wxString_in_helper(obj2);
14793 if (arg3 == NULL) SWIG_fail;
14794 temp3 = true;
14795 }
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14800
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 resultobj = result;
14805 {
14806 if (temp2)
14807 delete arg2;
14808 }
14809 {
14810 if (temp3)
14811 delete arg3;
14812 }
14813 return resultobj;
14814 fail:
14815 {
14816 if (temp2)
14817 delete arg2;
14818 }
14819 {
14820 if (temp3)
14821 delete arg3;
14822 }
14823 return NULL;
14824 }
14825
14826
14827 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14828 PyObject *resultobj;
14829 wxFileType *arg1 = (wxFileType *) 0 ;
14830 wxString *arg2 = 0 ;
14831 wxString *arg3 = 0 ;
14832 bool arg4 = (bool) true ;
14833 bool result;
14834 bool temp2 = false ;
14835 bool temp3 = false ;
14836 PyObject * obj0 = 0 ;
14837 PyObject * obj1 = 0 ;
14838 PyObject * obj2 = 0 ;
14839 PyObject * obj3 = 0 ;
14840 char *kwnames[] = {
14841 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14842 };
14843
14844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14846 if (SWIG_arg_fail(1)) SWIG_fail;
14847 {
14848 arg2 = wxString_in_helper(obj1);
14849 if (arg2 == NULL) SWIG_fail;
14850 temp2 = true;
14851 }
14852 {
14853 arg3 = wxString_in_helper(obj2);
14854 if (arg3 == NULL) SWIG_fail;
14855 temp3 = true;
14856 }
14857 if (obj3) {
14858 {
14859 arg4 = (bool)(SWIG_As_bool(obj3));
14860 if (SWIG_arg_fail(4)) SWIG_fail;
14861 }
14862 }
14863 {
14864 PyThreadState* __tstate = wxPyBeginAllowThreads();
14865 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14866
14867 wxPyEndAllowThreads(__tstate);
14868 if (PyErr_Occurred()) SWIG_fail;
14869 }
14870 {
14871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14872 }
14873 {
14874 if (temp2)
14875 delete arg2;
14876 }
14877 {
14878 if (temp3)
14879 delete arg3;
14880 }
14881 return resultobj;
14882 fail:
14883 {
14884 if (temp2)
14885 delete arg2;
14886 }
14887 {
14888 if (temp3)
14889 delete arg3;
14890 }
14891 return NULL;
14892 }
14893
14894
14895 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14896 PyObject *resultobj;
14897 wxFileType *arg1 = (wxFileType *) 0 ;
14898 wxString const &arg2_defvalue = wxPyEmptyString ;
14899 wxString *arg2 = (wxString *) &arg2_defvalue ;
14900 int arg3 = (int) 0 ;
14901 bool result;
14902 bool temp2 = false ;
14903 PyObject * obj0 = 0 ;
14904 PyObject * obj1 = 0 ;
14905 PyObject * obj2 = 0 ;
14906 char *kwnames[] = {
14907 (char *) "self",(char *) "cmd",(char *) "index", NULL
14908 };
14909
14910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14912 if (SWIG_arg_fail(1)) SWIG_fail;
14913 if (obj1) {
14914 {
14915 arg2 = wxString_in_helper(obj1);
14916 if (arg2 == NULL) SWIG_fail;
14917 temp2 = true;
14918 }
14919 }
14920 if (obj2) {
14921 {
14922 arg3 = (int)(SWIG_As_int(obj2));
14923 if (SWIG_arg_fail(3)) SWIG_fail;
14924 }
14925 }
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14929
14930 wxPyEndAllowThreads(__tstate);
14931 if (PyErr_Occurred()) SWIG_fail;
14932 }
14933 {
14934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14935 }
14936 {
14937 if (temp2)
14938 delete arg2;
14939 }
14940 return resultobj;
14941 fail:
14942 {
14943 if (temp2)
14944 delete arg2;
14945 }
14946 return NULL;
14947 }
14948
14949
14950 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14951 PyObject *resultobj;
14952 wxFileType *arg1 = (wxFileType *) 0 ;
14953 bool result;
14954 PyObject * obj0 = 0 ;
14955 char *kwnames[] = {
14956 (char *) "self", NULL
14957 };
14958
14959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14961 if (SWIG_arg_fail(1)) SWIG_fail;
14962 {
14963 PyThreadState* __tstate = wxPyBeginAllowThreads();
14964 result = (bool)(arg1)->Unassociate();
14965
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 {
14970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14971 }
14972 return resultobj;
14973 fail:
14974 return NULL;
14975 }
14976
14977
14978 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14979 PyObject *resultobj;
14980 wxString *arg1 = 0 ;
14981 wxString *arg2 = 0 ;
14982 wxString const &arg3_defvalue = wxPyEmptyString ;
14983 wxString *arg3 = (wxString *) &arg3_defvalue ;
14984 wxString result;
14985 bool temp1 = false ;
14986 bool temp2 = false ;
14987 bool temp3 = false ;
14988 PyObject * obj0 = 0 ;
14989 PyObject * obj1 = 0 ;
14990 PyObject * obj2 = 0 ;
14991 char *kwnames[] = {
14992 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14993 };
14994
14995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14996 {
14997 arg1 = wxString_in_helper(obj0);
14998 if (arg1 == NULL) SWIG_fail;
14999 temp1 = true;
15000 }
15001 {
15002 arg2 = wxString_in_helper(obj1);
15003 if (arg2 == NULL) SWIG_fail;
15004 temp2 = true;
15005 }
15006 if (obj2) {
15007 {
15008 arg3 = wxString_in_helper(obj2);
15009 if (arg3 == NULL) SWIG_fail;
15010 temp3 = true;
15011 }
15012 }
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15016
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 {
15021 #if wxUSE_UNICODE
15022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15023 #else
15024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15025 #endif
15026 }
15027 {
15028 if (temp1)
15029 delete arg1;
15030 }
15031 {
15032 if (temp2)
15033 delete arg2;
15034 }
15035 {
15036 if (temp3)
15037 delete arg3;
15038 }
15039 return resultobj;
15040 fail:
15041 {
15042 if (temp1)
15043 delete arg1;
15044 }
15045 {
15046 if (temp2)
15047 delete arg2;
15048 }
15049 {
15050 if (temp3)
15051 delete arg3;
15052 }
15053 return NULL;
15054 }
15055
15056
15057 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15058 PyObject *obj;
15059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15060 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15061 Py_INCREF(obj);
15062 return Py_BuildValue((char *)"");
15063 }
15064 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15065 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15066 return 1;
15067 }
15068
15069
15070 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15071 PyObject *pyobj;
15072
15073 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15074 return pyobj;
15075 }
15076
15077
15078 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15079 PyObject *resultobj;
15080 wxString *arg1 = 0 ;
15081 wxString *arg2 = 0 ;
15082 bool result;
15083 bool temp1 = false ;
15084 bool temp2 = false ;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 char *kwnames[] = {
15088 (char *) "mimeType",(char *) "wildcard", NULL
15089 };
15090
15091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15092 {
15093 arg1 = wxString_in_helper(obj0);
15094 if (arg1 == NULL) SWIG_fail;
15095 temp1 = true;
15096 }
15097 {
15098 arg2 = wxString_in_helper(obj1);
15099 if (arg2 == NULL) SWIG_fail;
15100 temp2 = true;
15101 }
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 {
15110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15111 }
15112 {
15113 if (temp1)
15114 delete arg1;
15115 }
15116 {
15117 if (temp2)
15118 delete arg2;
15119 }
15120 return resultobj;
15121 fail:
15122 {
15123 if (temp1)
15124 delete arg1;
15125 }
15126 {
15127 if (temp2)
15128 delete arg2;
15129 }
15130 return NULL;
15131 }
15132
15133
15134 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15135 PyObject *resultobj;
15136 wxMimeTypesManager *result;
15137 char *kwnames[] = {
15138 NULL
15139 };
15140
15141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15145
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15150 return resultobj;
15151 fail:
15152 return NULL;
15153 }
15154
15155
15156 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15157 PyObject *resultobj;
15158 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15159 int arg2 = (int) wxMAILCAP_ALL ;
15160 wxString const &arg3_defvalue = wxPyEmptyString ;
15161 wxString *arg3 = (wxString *) &arg3_defvalue ;
15162 bool temp3 = false ;
15163 PyObject * obj0 = 0 ;
15164 PyObject * obj1 = 0 ;
15165 PyObject * obj2 = 0 ;
15166 char *kwnames[] = {
15167 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15168 };
15169
15170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15172 if (SWIG_arg_fail(1)) SWIG_fail;
15173 if (obj1) {
15174 {
15175 arg2 = (int)(SWIG_As_int(obj1));
15176 if (SWIG_arg_fail(2)) SWIG_fail;
15177 }
15178 }
15179 if (obj2) {
15180 {
15181 arg3 = wxString_in_helper(obj2);
15182 if (arg3 == NULL) SWIG_fail;
15183 temp3 = true;
15184 }
15185 }
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15189
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 Py_INCREF(Py_None); resultobj = Py_None;
15194 {
15195 if (temp3)
15196 delete arg3;
15197 }
15198 return resultobj;
15199 fail:
15200 {
15201 if (temp3)
15202 delete arg3;
15203 }
15204 return NULL;
15205 }
15206
15207
15208 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15209 PyObject *resultobj;
15210 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15211 PyObject * obj0 = 0 ;
15212 char *kwnames[] = {
15213 (char *) "self", NULL
15214 };
15215
15216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15218 if (SWIG_arg_fail(1)) SWIG_fail;
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 (arg1)->ClearData();
15222
15223 wxPyEndAllowThreads(__tstate);
15224 if (PyErr_Occurred()) SWIG_fail;
15225 }
15226 Py_INCREF(Py_None); resultobj = Py_None;
15227 return resultobj;
15228 fail:
15229 return NULL;
15230 }
15231
15232
15233 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15234 PyObject *resultobj;
15235 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15236 wxString *arg2 = 0 ;
15237 wxFileType *result;
15238 bool temp2 = false ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 char *kwnames[] = {
15242 (char *) "self",(char *) "ext", NULL
15243 };
15244
15245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15247 if (SWIG_arg_fail(1)) SWIG_fail;
15248 {
15249 arg2 = wxString_in_helper(obj1);
15250 if (arg2 == NULL) SWIG_fail;
15251 temp2 = true;
15252 }
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15261 {
15262 if (temp2)
15263 delete arg2;
15264 }
15265 return resultobj;
15266 fail:
15267 {
15268 if (temp2)
15269 delete arg2;
15270 }
15271 return NULL;
15272 }
15273
15274
15275 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj;
15277 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15278 wxString *arg2 = 0 ;
15279 wxFileType *result;
15280 bool temp2 = false ;
15281 PyObject * obj0 = 0 ;
15282 PyObject * obj1 = 0 ;
15283 char *kwnames[] = {
15284 (char *) "self",(char *) "mimeType", NULL
15285 };
15286
15287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15289 if (SWIG_arg_fail(1)) SWIG_fail;
15290 {
15291 arg2 = wxString_in_helper(obj1);
15292 if (arg2 == NULL) SWIG_fail;
15293 temp2 = true;
15294 }
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15298
15299 wxPyEndAllowThreads(__tstate);
15300 if (PyErr_Occurred()) SWIG_fail;
15301 }
15302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15303 {
15304 if (temp2)
15305 delete arg2;
15306 }
15307 return resultobj;
15308 fail:
15309 {
15310 if (temp2)
15311 delete arg2;
15312 }
15313 return NULL;
15314 }
15315
15316
15317 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15318 PyObject *resultobj;
15319 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15320 wxString *arg2 = 0 ;
15321 bool arg3 = (bool) false ;
15322 bool result;
15323 bool temp2 = false ;
15324 PyObject * obj0 = 0 ;
15325 PyObject * obj1 = 0 ;
15326 PyObject * obj2 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 arg2 = wxString_in_helper(obj1);
15336 if (arg2 == NULL) SWIG_fail;
15337 temp2 = true;
15338 }
15339 if (obj2) {
15340 {
15341 arg3 = (bool)(SWIG_As_bool(obj2));
15342 if (SWIG_arg_fail(3)) SWIG_fail;
15343 }
15344 }
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15348
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 {
15353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15354 }
15355 {
15356 if (temp2)
15357 delete arg2;
15358 }
15359 return resultobj;
15360 fail:
15361 {
15362 if (temp2)
15363 delete arg2;
15364 }
15365 return NULL;
15366 }
15367
15368
15369 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15370 PyObject *resultobj;
15371 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15372 wxString *arg2 = 0 ;
15373 bool result;
15374 bool temp2 = false ;
15375 PyObject * obj0 = 0 ;
15376 PyObject * obj1 = 0 ;
15377 char *kwnames[] = {
15378 (char *) "self",(char *) "filename", NULL
15379 };
15380
15381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15383 if (SWIG_arg_fail(1)) SWIG_fail;
15384 {
15385 arg2 = wxString_in_helper(obj1);
15386 if (arg2 == NULL) SWIG_fail;
15387 temp2 = true;
15388 }
15389 {
15390 PyThreadState* __tstate = wxPyBeginAllowThreads();
15391 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15392
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 {
15397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15398 }
15399 {
15400 if (temp2)
15401 delete arg2;
15402 }
15403 return resultobj;
15404 fail:
15405 {
15406 if (temp2)
15407 delete arg2;
15408 }
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15416 PyObject *result;
15417 PyObject * obj0 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 resultobj = result;
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15440 PyObject *resultobj;
15441 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15442 wxFileTypeInfo *arg2 = 0 ;
15443 PyObject * obj0 = 0 ;
15444 PyObject * obj1 = 0 ;
15445 char *kwnames[] = {
15446 (char *) "self",(char *) "ft", NULL
15447 };
15448
15449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15451 if (SWIG_arg_fail(1)) SWIG_fail;
15452 {
15453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15454 if (SWIG_arg_fail(2)) SWIG_fail;
15455 if (arg2 == NULL) {
15456 SWIG_null_ref("wxFileTypeInfo");
15457 }
15458 if (SWIG_arg_fail(2)) SWIG_fail;
15459 }
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15463
15464 wxPyEndAllowThreads(__tstate);
15465 if (PyErr_Occurred()) SWIG_fail;
15466 }
15467 Py_INCREF(Py_None); resultobj = Py_None;
15468 return resultobj;
15469 fail:
15470 return NULL;
15471 }
15472
15473
15474 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15475 PyObject *resultobj;
15476 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15477 wxFileTypeInfo *arg2 = 0 ;
15478 wxFileType *result;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 char *kwnames[] = {
15482 (char *) "self",(char *) "ftInfo", NULL
15483 };
15484
15485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15487 if (SWIG_arg_fail(1)) SWIG_fail;
15488 {
15489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15490 if (SWIG_arg_fail(2)) SWIG_fail;
15491 if (arg2 == NULL) {
15492 SWIG_null_ref("wxFileTypeInfo");
15493 }
15494 if (SWIG_arg_fail(2)) SWIG_fail;
15495 }
15496 {
15497 PyThreadState* __tstate = wxPyBeginAllowThreads();
15498 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15499
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15504 return resultobj;
15505 fail:
15506 return NULL;
15507 }
15508
15509
15510 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15511 PyObject *resultobj;
15512 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15513 wxFileType *arg2 = (wxFileType *) 0 ;
15514 bool result;
15515 PyObject * obj0 = 0 ;
15516 PyObject * obj1 = 0 ;
15517 char *kwnames[] = {
15518 (char *) "self",(char *) "ft", NULL
15519 };
15520
15521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15523 if (SWIG_arg_fail(1)) SWIG_fail;
15524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15525 if (SWIG_arg_fail(2)) SWIG_fail;
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 result = (bool)(arg1)->Unassociate(arg2);
15529
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 {
15534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15535 }
15536 return resultobj;
15537 fail:
15538 return NULL;
15539 }
15540
15541
15542 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15543 PyObject *resultobj;
15544 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15545 PyObject * obj0 = 0 ;
15546 char *kwnames[] = {
15547 (char *) "self", NULL
15548 };
15549
15550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15552 if (SWIG_arg_fail(1)) SWIG_fail;
15553 {
15554 PyThreadState* __tstate = wxPyBeginAllowThreads();
15555 delete arg1;
15556
15557 wxPyEndAllowThreads(__tstate);
15558 if (PyErr_Occurred()) SWIG_fail;
15559 }
15560 Py_INCREF(Py_None); resultobj = Py_None;
15561 return resultobj;
15562 fail:
15563 return NULL;
15564 }
15565
15566
15567 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15568 PyObject *obj;
15569 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15570 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15571 Py_INCREF(obj);
15572 return Py_BuildValue((char *)"");
15573 }
15574 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15575 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15576 return 1;
15577 }
15578
15579
15580 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15581 PyObject *pyobj;
15582
15583 {
15584 #if wxUSE_UNICODE
15585 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15586 #else
15587 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15588 #endif
15589 }
15590 return pyobj;
15591 }
15592
15593
15594 static int _wrap_ART_MENU_set(PyObject *) {
15595 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15596 return 1;
15597 }
15598
15599
15600 static PyObject *_wrap_ART_MENU_get(void) {
15601 PyObject *pyobj;
15602
15603 {
15604 #if wxUSE_UNICODE
15605 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15606 #else
15607 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15608 #endif
15609 }
15610 return pyobj;
15611 }
15612
15613
15614 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15615 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15616 return 1;
15617 }
15618
15619
15620 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15621 PyObject *pyobj;
15622
15623 {
15624 #if wxUSE_UNICODE
15625 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15626 #else
15627 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15628 #endif
15629 }
15630 return pyobj;
15631 }
15632
15633
15634 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15635 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15636 return 1;
15637 }
15638
15639
15640 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15641 PyObject *pyobj;
15642
15643 {
15644 #if wxUSE_UNICODE
15645 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15646 #else
15647 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15648 #endif
15649 }
15650 return pyobj;
15651 }
15652
15653
15654 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15655 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15656 return 1;
15657 }
15658
15659
15660 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15661 PyObject *pyobj;
15662
15663 {
15664 #if wxUSE_UNICODE
15665 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15666 #else
15667 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15668 #endif
15669 }
15670 return pyobj;
15671 }
15672
15673
15674 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15675 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15676 return 1;
15677 }
15678
15679
15680 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15681 PyObject *pyobj;
15682
15683 {
15684 #if wxUSE_UNICODE
15685 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15686 #else
15687 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15688 #endif
15689 }
15690 return pyobj;
15691 }
15692
15693
15694 static int _wrap_ART_BUTTON_set(PyObject *) {
15695 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15696 return 1;
15697 }
15698
15699
15700 static PyObject *_wrap_ART_BUTTON_get(void) {
15701 PyObject *pyobj;
15702
15703 {
15704 #if wxUSE_UNICODE
15705 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15706 #else
15707 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15708 #endif
15709 }
15710 return pyobj;
15711 }
15712
15713
15714 static int _wrap_ART_OTHER_set(PyObject *) {
15715 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15716 return 1;
15717 }
15718
15719
15720 static PyObject *_wrap_ART_OTHER_get(void) {
15721 PyObject *pyobj;
15722
15723 {
15724 #if wxUSE_UNICODE
15725 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15726 #else
15727 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15728 #endif
15729 }
15730 return pyobj;
15731 }
15732
15733
15734 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15735 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15736 return 1;
15737 }
15738
15739
15740 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15741 PyObject *pyobj;
15742
15743 {
15744 #if wxUSE_UNICODE
15745 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15746 #else
15747 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15748 #endif
15749 }
15750 return pyobj;
15751 }
15752
15753
15754 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15755 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15756 return 1;
15757 }
15758
15759
15760 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15761 PyObject *pyobj;
15762
15763 {
15764 #if wxUSE_UNICODE
15765 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15766 #else
15767 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15768 #endif
15769 }
15770 return pyobj;
15771 }
15772
15773
15774 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15775 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15776 return 1;
15777 }
15778
15779
15780 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15781 PyObject *pyobj;
15782
15783 {
15784 #if wxUSE_UNICODE
15785 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15786 #else
15787 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15788 #endif
15789 }
15790 return pyobj;
15791 }
15792
15793
15794 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15795 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15796 return 1;
15797 }
15798
15799
15800 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15801 PyObject *pyobj;
15802
15803 {
15804 #if wxUSE_UNICODE
15805 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15806 #else
15807 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15808 #endif
15809 }
15810 return pyobj;
15811 }
15812
15813
15814 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15815 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15816 return 1;
15817 }
15818
15819
15820 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15821 PyObject *pyobj;
15822
15823 {
15824 #if wxUSE_UNICODE
15825 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15826 #else
15827 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15828 #endif
15829 }
15830 return pyobj;
15831 }
15832
15833
15834 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15835 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15836 return 1;
15837 }
15838
15839
15840 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15841 PyObject *pyobj;
15842
15843 {
15844 #if wxUSE_UNICODE
15845 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15846 #else
15847 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15848 #endif
15849 }
15850 return pyobj;
15851 }
15852
15853
15854 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15855 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15856 return 1;
15857 }
15858
15859
15860 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15861 PyObject *pyobj;
15862
15863 {
15864 #if wxUSE_UNICODE
15865 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15866 #else
15867 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15868 #endif
15869 }
15870 return pyobj;
15871 }
15872
15873
15874 static int _wrap_ART_GO_BACK_set(PyObject *) {
15875 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15876 return 1;
15877 }
15878
15879
15880 static PyObject *_wrap_ART_GO_BACK_get(void) {
15881 PyObject *pyobj;
15882
15883 {
15884 #if wxUSE_UNICODE
15885 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15886 #else
15887 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15888 #endif
15889 }
15890 return pyobj;
15891 }
15892
15893
15894 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15895 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15896 return 1;
15897 }
15898
15899
15900 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15901 PyObject *pyobj;
15902
15903 {
15904 #if wxUSE_UNICODE
15905 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15906 #else
15907 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15908 #endif
15909 }
15910 return pyobj;
15911 }
15912
15913
15914 static int _wrap_ART_GO_UP_set(PyObject *) {
15915 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15916 return 1;
15917 }
15918
15919
15920 static PyObject *_wrap_ART_GO_UP_get(void) {
15921 PyObject *pyobj;
15922
15923 {
15924 #if wxUSE_UNICODE
15925 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15926 #else
15927 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15928 #endif
15929 }
15930 return pyobj;
15931 }
15932
15933
15934 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15935 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15936 return 1;
15937 }
15938
15939
15940 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15941 PyObject *pyobj;
15942
15943 {
15944 #if wxUSE_UNICODE
15945 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15946 #else
15947 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15948 #endif
15949 }
15950 return pyobj;
15951 }
15952
15953
15954 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15955 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15956 return 1;
15957 }
15958
15959
15960 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15961 PyObject *pyobj;
15962
15963 {
15964 #if wxUSE_UNICODE
15965 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15966 #else
15967 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15968 #endif
15969 }
15970 return pyobj;
15971 }
15972
15973
15974 static int _wrap_ART_GO_HOME_set(PyObject *) {
15975 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15976 return 1;
15977 }
15978
15979
15980 static PyObject *_wrap_ART_GO_HOME_get(void) {
15981 PyObject *pyobj;
15982
15983 {
15984 #if wxUSE_UNICODE
15985 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15986 #else
15987 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15988 #endif
15989 }
15990 return pyobj;
15991 }
15992
15993
15994 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15995 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15996 return 1;
15997 }
15998
15999
16000 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16001 PyObject *pyobj;
16002
16003 {
16004 #if wxUSE_UNICODE
16005 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16006 #else
16007 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16008 #endif
16009 }
16010 return pyobj;
16011 }
16012
16013
16014 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16015 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16016 return 1;
16017 }
16018
16019
16020 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16021 PyObject *pyobj;
16022
16023 {
16024 #if wxUSE_UNICODE
16025 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16026 #else
16027 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16028 #endif
16029 }
16030 return pyobj;
16031 }
16032
16033
16034 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16035 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16036 return 1;
16037 }
16038
16039
16040 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16041 PyObject *pyobj;
16042
16043 {
16044 #if wxUSE_UNICODE
16045 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16046 #else
16047 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16048 #endif
16049 }
16050 return pyobj;
16051 }
16052
16053
16054 static int _wrap_ART_PRINT_set(PyObject *) {
16055 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16056 return 1;
16057 }
16058
16059
16060 static PyObject *_wrap_ART_PRINT_get(void) {
16061 PyObject *pyobj;
16062
16063 {
16064 #if wxUSE_UNICODE
16065 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16066 #else
16067 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16068 #endif
16069 }
16070 return pyobj;
16071 }
16072
16073
16074 static int _wrap_ART_HELP_set(PyObject *) {
16075 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16076 return 1;
16077 }
16078
16079
16080 static PyObject *_wrap_ART_HELP_get(void) {
16081 PyObject *pyobj;
16082
16083 {
16084 #if wxUSE_UNICODE
16085 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16086 #else
16087 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16088 #endif
16089 }
16090 return pyobj;
16091 }
16092
16093
16094 static int _wrap_ART_TIP_set(PyObject *) {
16095 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16096 return 1;
16097 }
16098
16099
16100 static PyObject *_wrap_ART_TIP_get(void) {
16101 PyObject *pyobj;
16102
16103 {
16104 #if wxUSE_UNICODE
16105 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16106 #else
16107 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16108 #endif
16109 }
16110 return pyobj;
16111 }
16112
16113
16114 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16115 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16116 return 1;
16117 }
16118
16119
16120 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16121 PyObject *pyobj;
16122
16123 {
16124 #if wxUSE_UNICODE
16125 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16126 #else
16127 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16128 #endif
16129 }
16130 return pyobj;
16131 }
16132
16133
16134 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16135 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16136 return 1;
16137 }
16138
16139
16140 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16141 PyObject *pyobj;
16142
16143 {
16144 #if wxUSE_UNICODE
16145 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16146 #else
16147 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16148 #endif
16149 }
16150 return pyobj;
16151 }
16152
16153
16154 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16155 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16156 return 1;
16157 }
16158
16159
16160 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16161 PyObject *pyobj;
16162
16163 {
16164 #if wxUSE_UNICODE
16165 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16166 #else
16167 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16168 #endif
16169 }
16170 return pyobj;
16171 }
16172
16173
16174 static int _wrap_ART_HARDDISK_set(PyObject *) {
16175 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16176 return 1;
16177 }
16178
16179
16180 static PyObject *_wrap_ART_HARDDISK_get(void) {
16181 PyObject *pyobj;
16182
16183 {
16184 #if wxUSE_UNICODE
16185 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16186 #else
16187 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16188 #endif
16189 }
16190 return pyobj;
16191 }
16192
16193
16194 static int _wrap_ART_FLOPPY_set(PyObject *) {
16195 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16196 return 1;
16197 }
16198
16199
16200 static PyObject *_wrap_ART_FLOPPY_get(void) {
16201 PyObject *pyobj;
16202
16203 {
16204 #if wxUSE_UNICODE
16205 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16206 #else
16207 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16208 #endif
16209 }
16210 return pyobj;
16211 }
16212
16213
16214 static int _wrap_ART_CDROM_set(PyObject *) {
16215 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16216 return 1;
16217 }
16218
16219
16220 static PyObject *_wrap_ART_CDROM_get(void) {
16221 PyObject *pyobj;
16222
16223 {
16224 #if wxUSE_UNICODE
16225 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16226 #else
16227 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16228 #endif
16229 }
16230 return pyobj;
16231 }
16232
16233
16234 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16235 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16236 return 1;
16237 }
16238
16239
16240 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16241 PyObject *pyobj;
16242
16243 {
16244 #if wxUSE_UNICODE
16245 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16246 #else
16247 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16248 #endif
16249 }
16250 return pyobj;
16251 }
16252
16253
16254 static int _wrap_ART_FOLDER_set(PyObject *) {
16255 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16256 return 1;
16257 }
16258
16259
16260 static PyObject *_wrap_ART_FOLDER_get(void) {
16261 PyObject *pyobj;
16262
16263 {
16264 #if wxUSE_UNICODE
16265 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16266 #else
16267 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16268 #endif
16269 }
16270 return pyobj;
16271 }
16272
16273
16274 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16275 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16276 return 1;
16277 }
16278
16279
16280 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16281 PyObject *pyobj;
16282
16283 {
16284 #if wxUSE_UNICODE
16285 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16286 #else
16287 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16288 #endif
16289 }
16290 return pyobj;
16291 }
16292
16293
16294 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16295 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16296 return 1;
16297 }
16298
16299
16300 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16301 PyObject *pyobj;
16302
16303 {
16304 #if wxUSE_UNICODE
16305 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16306 #else
16307 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16308 #endif
16309 }
16310 return pyobj;
16311 }
16312
16313
16314 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16315 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16316 return 1;
16317 }
16318
16319
16320 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16321 PyObject *pyobj;
16322
16323 {
16324 #if wxUSE_UNICODE
16325 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16326 #else
16327 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16328 #endif
16329 }
16330 return pyobj;
16331 }
16332
16333
16334 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16335 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16336 return 1;
16337 }
16338
16339
16340 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16341 PyObject *pyobj;
16342
16343 {
16344 #if wxUSE_UNICODE
16345 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16346 #else
16347 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16348 #endif
16349 }
16350 return pyobj;
16351 }
16352
16353
16354 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16355 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16356 return 1;
16357 }
16358
16359
16360 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16361 PyObject *pyobj;
16362
16363 {
16364 #if wxUSE_UNICODE
16365 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16366 #else
16367 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16368 #endif
16369 }
16370 return pyobj;
16371 }
16372
16373
16374 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16375 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16376 return 1;
16377 }
16378
16379
16380 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16381 PyObject *pyobj;
16382
16383 {
16384 #if wxUSE_UNICODE
16385 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16386 #else
16387 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16388 #endif
16389 }
16390 return pyobj;
16391 }
16392
16393
16394 static int _wrap_ART_ERROR_set(PyObject *) {
16395 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16396 return 1;
16397 }
16398
16399
16400 static PyObject *_wrap_ART_ERROR_get(void) {
16401 PyObject *pyobj;
16402
16403 {
16404 #if wxUSE_UNICODE
16405 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16406 #else
16407 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16408 #endif
16409 }
16410 return pyobj;
16411 }
16412
16413
16414 static int _wrap_ART_QUESTION_set(PyObject *) {
16415 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16416 return 1;
16417 }
16418
16419
16420 static PyObject *_wrap_ART_QUESTION_get(void) {
16421 PyObject *pyobj;
16422
16423 {
16424 #if wxUSE_UNICODE
16425 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16426 #else
16427 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16428 #endif
16429 }
16430 return pyobj;
16431 }
16432
16433
16434 static int _wrap_ART_WARNING_set(PyObject *) {
16435 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16436 return 1;
16437 }
16438
16439
16440 static PyObject *_wrap_ART_WARNING_get(void) {
16441 PyObject *pyobj;
16442
16443 {
16444 #if wxUSE_UNICODE
16445 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16446 #else
16447 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16448 #endif
16449 }
16450 return pyobj;
16451 }
16452
16453
16454 static int _wrap_ART_INFORMATION_set(PyObject *) {
16455 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16456 return 1;
16457 }
16458
16459
16460 static PyObject *_wrap_ART_INFORMATION_get(void) {
16461 PyObject *pyobj;
16462
16463 {
16464 #if wxUSE_UNICODE
16465 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16466 #else
16467 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16468 #endif
16469 }
16470 return pyobj;
16471 }
16472
16473
16474 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16475 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16476 return 1;
16477 }
16478
16479
16480 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16481 PyObject *pyobj;
16482
16483 {
16484 #if wxUSE_UNICODE
16485 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16486 #else
16487 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16488 #endif
16489 }
16490 return pyobj;
16491 }
16492
16493
16494 static int _wrap_ART_COPY_set(PyObject *) {
16495 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16496 return 1;
16497 }
16498
16499
16500 static PyObject *_wrap_ART_COPY_get(void) {
16501 PyObject *pyobj;
16502
16503 {
16504 #if wxUSE_UNICODE
16505 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16506 #else
16507 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16508 #endif
16509 }
16510 return pyobj;
16511 }
16512
16513
16514 static int _wrap_ART_CUT_set(PyObject *) {
16515 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16516 return 1;
16517 }
16518
16519
16520 static PyObject *_wrap_ART_CUT_get(void) {
16521 PyObject *pyobj;
16522
16523 {
16524 #if wxUSE_UNICODE
16525 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16526 #else
16527 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16528 #endif
16529 }
16530 return pyobj;
16531 }
16532
16533
16534 static int _wrap_ART_PASTE_set(PyObject *) {
16535 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16536 return 1;
16537 }
16538
16539
16540 static PyObject *_wrap_ART_PASTE_get(void) {
16541 PyObject *pyobj;
16542
16543 {
16544 #if wxUSE_UNICODE
16545 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16546 #else
16547 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16548 #endif
16549 }
16550 return pyobj;
16551 }
16552
16553
16554 static int _wrap_ART_DELETE_set(PyObject *) {
16555 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16556 return 1;
16557 }
16558
16559
16560 static PyObject *_wrap_ART_DELETE_get(void) {
16561 PyObject *pyobj;
16562
16563 {
16564 #if wxUSE_UNICODE
16565 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16566 #else
16567 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16568 #endif
16569 }
16570 return pyobj;
16571 }
16572
16573
16574 static int _wrap_ART_NEW_set(PyObject *) {
16575 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
16576 return 1;
16577 }
16578
16579
16580 static PyObject *_wrap_ART_NEW_get(void) {
16581 PyObject *pyobj;
16582
16583 {
16584 #if wxUSE_UNICODE
16585 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16586 #else
16587 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
16588 #endif
16589 }
16590 return pyobj;
16591 }
16592
16593
16594 static int _wrap_ART_UNDO_set(PyObject *) {
16595 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16596 return 1;
16597 }
16598
16599
16600 static PyObject *_wrap_ART_UNDO_get(void) {
16601 PyObject *pyobj;
16602
16603 {
16604 #if wxUSE_UNICODE
16605 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16606 #else
16607 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16608 #endif
16609 }
16610 return pyobj;
16611 }
16612
16613
16614 static int _wrap_ART_REDO_set(PyObject *) {
16615 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16616 return 1;
16617 }
16618
16619
16620 static PyObject *_wrap_ART_REDO_get(void) {
16621 PyObject *pyobj;
16622
16623 {
16624 #if wxUSE_UNICODE
16625 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16626 #else
16627 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16628 #endif
16629 }
16630 return pyobj;
16631 }
16632
16633
16634 static int _wrap_ART_QUIT_set(PyObject *) {
16635 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16636 return 1;
16637 }
16638
16639
16640 static PyObject *_wrap_ART_QUIT_get(void) {
16641 PyObject *pyobj;
16642
16643 {
16644 #if wxUSE_UNICODE
16645 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16646 #else
16647 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16648 #endif
16649 }
16650 return pyobj;
16651 }
16652
16653
16654 static int _wrap_ART_FIND_set(PyObject *) {
16655 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16656 return 1;
16657 }
16658
16659
16660 static PyObject *_wrap_ART_FIND_get(void) {
16661 PyObject *pyobj;
16662
16663 {
16664 #if wxUSE_UNICODE
16665 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16666 #else
16667 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16668 #endif
16669 }
16670 return pyobj;
16671 }
16672
16673
16674 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16675 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16676 return 1;
16677 }
16678
16679
16680 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16681 PyObject *pyobj;
16682
16683 {
16684 #if wxUSE_UNICODE
16685 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16686 #else
16687 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16688 #endif
16689 }
16690 return pyobj;
16691 }
16692
16693
16694 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16695 PyObject *resultobj;
16696 wxPyArtProvider *result;
16697 char *kwnames[] = {
16698 NULL
16699 };
16700
16701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16702 {
16703 if (!wxPyCheckForApp()) SWIG_fail;
16704 PyThreadState* __tstate = wxPyBeginAllowThreads();
16705 result = (wxPyArtProvider *)new wxPyArtProvider();
16706
16707 wxPyEndAllowThreads(__tstate);
16708 if (PyErr_Occurred()) SWIG_fail;
16709 }
16710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16718 PyObject *resultobj;
16719 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16720 PyObject *arg2 = (PyObject *) 0 ;
16721 PyObject *arg3 = (PyObject *) 0 ;
16722 PyObject * obj0 = 0 ;
16723 PyObject * obj1 = 0 ;
16724 PyObject * obj2 = 0 ;
16725 char *kwnames[] = {
16726 (char *) "self",(char *) "self",(char *) "_class", NULL
16727 };
16728
16729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16731 if (SWIG_arg_fail(1)) SWIG_fail;
16732 arg2 = obj1;
16733 arg3 = obj2;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 (arg1)->_setCallbackInfo(arg2,arg3);
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 Py_INCREF(Py_None); resultobj = Py_None;
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj;
16750 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16751 PyObject * obj0 = 0 ;
16752 char *kwnames[] = {
16753 (char *) "provider", NULL
16754 };
16755
16756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16758 if (SWIG_arg_fail(1)) SWIG_fail;
16759 {
16760 PyThreadState* __tstate = wxPyBeginAllowThreads();
16761 wxPyArtProvider::PushProvider(arg1);
16762
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 Py_INCREF(Py_None); resultobj = Py_None;
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj;
16775 bool result;
16776 char *kwnames[] = {
16777 NULL
16778 };
16779
16780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 result = (bool)wxPyArtProvider::PopProvider();
16784
16785 wxPyEndAllowThreads(__tstate);
16786 if (PyErr_Occurred()) SWIG_fail;
16787 }
16788 {
16789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16790 }
16791 return resultobj;
16792 fail:
16793 return NULL;
16794 }
16795
16796
16797 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj;
16799 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16800 bool result;
16801 PyObject * obj0 = 0 ;
16802 char *kwnames[] = {
16803 (char *) "provider", NULL
16804 };
16805
16806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16808 if (SWIG_arg_fail(1)) SWIG_fail;
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16812
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 {
16817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16818 }
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj;
16827 wxString *arg1 = 0 ;
16828 wxString const &arg2_defvalue = wxPyART_OTHER ;
16829 wxString *arg2 = (wxString *) &arg2_defvalue ;
16830 wxSize const &arg3_defvalue = wxDefaultSize ;
16831 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16832 wxBitmap result;
16833 bool temp1 = false ;
16834 bool temp2 = false ;
16835 wxSize temp3 ;
16836 PyObject * obj0 = 0 ;
16837 PyObject * obj1 = 0 ;
16838 PyObject * obj2 = 0 ;
16839 char *kwnames[] = {
16840 (char *) "id",(char *) "client",(char *) "size", NULL
16841 };
16842
16843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16844 {
16845 arg1 = wxString_in_helper(obj0);
16846 if (arg1 == NULL) SWIG_fail;
16847 temp1 = true;
16848 }
16849 if (obj1) {
16850 {
16851 arg2 = wxString_in_helper(obj1);
16852 if (arg2 == NULL) SWIG_fail;
16853 temp2 = true;
16854 }
16855 }
16856 if (obj2) {
16857 {
16858 arg3 = &temp3;
16859 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16860 }
16861 }
16862 {
16863 if (!wxPyCheckForApp()) SWIG_fail;
16864 PyThreadState* __tstate = wxPyBeginAllowThreads();
16865 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16866
16867 wxPyEndAllowThreads(__tstate);
16868 if (PyErr_Occurred()) SWIG_fail;
16869 }
16870 {
16871 wxBitmap * resultptr;
16872 resultptr = new wxBitmap((wxBitmap &)(result));
16873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16874 }
16875 {
16876 if (temp1)
16877 delete arg1;
16878 }
16879 {
16880 if (temp2)
16881 delete arg2;
16882 }
16883 return resultobj;
16884 fail:
16885 {
16886 if (temp1)
16887 delete arg1;
16888 }
16889 {
16890 if (temp2)
16891 delete arg2;
16892 }
16893 return NULL;
16894 }
16895
16896
16897 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16898 PyObject *resultobj;
16899 wxString *arg1 = 0 ;
16900 wxString const &arg2_defvalue = wxPyART_OTHER ;
16901 wxString *arg2 = (wxString *) &arg2_defvalue ;
16902 wxSize const &arg3_defvalue = wxDefaultSize ;
16903 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16904 wxIcon result;
16905 bool temp1 = false ;
16906 bool temp2 = false ;
16907 wxSize temp3 ;
16908 PyObject * obj0 = 0 ;
16909 PyObject * obj1 = 0 ;
16910 PyObject * obj2 = 0 ;
16911 char *kwnames[] = {
16912 (char *) "id",(char *) "client",(char *) "size", NULL
16913 };
16914
16915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16916 {
16917 arg1 = wxString_in_helper(obj0);
16918 if (arg1 == NULL) SWIG_fail;
16919 temp1 = true;
16920 }
16921 if (obj1) {
16922 {
16923 arg2 = wxString_in_helper(obj1);
16924 if (arg2 == NULL) SWIG_fail;
16925 temp2 = true;
16926 }
16927 }
16928 if (obj2) {
16929 {
16930 arg3 = &temp3;
16931 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16932 }
16933 }
16934 {
16935 if (!wxPyCheckForApp()) SWIG_fail;
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16938
16939 wxPyEndAllowThreads(__tstate);
16940 if (PyErr_Occurred()) SWIG_fail;
16941 }
16942 {
16943 wxIcon * resultptr;
16944 resultptr = new wxIcon((wxIcon &)(result));
16945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16946 }
16947 {
16948 if (temp1)
16949 delete arg1;
16950 }
16951 {
16952 if (temp2)
16953 delete arg2;
16954 }
16955 return resultobj;
16956 fail:
16957 {
16958 if (temp1)
16959 delete arg1;
16960 }
16961 {
16962 if (temp2)
16963 delete arg2;
16964 }
16965 return NULL;
16966 }
16967
16968
16969 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj;
16971 wxString *arg1 = 0 ;
16972 bool arg2 = (bool) false ;
16973 wxSize result;
16974 bool temp1 = false ;
16975 PyObject * obj0 = 0 ;
16976 PyObject * obj1 = 0 ;
16977 char *kwnames[] = {
16978 (char *) "client",(char *) "platform_dependent", NULL
16979 };
16980
16981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16982 {
16983 arg1 = wxString_in_helper(obj0);
16984 if (arg1 == NULL) SWIG_fail;
16985 temp1 = true;
16986 }
16987 if (obj1) {
16988 {
16989 arg2 = (bool)(SWIG_As_bool(obj1));
16990 if (SWIG_arg_fail(2)) SWIG_fail;
16991 }
16992 }
16993 {
16994 PyThreadState* __tstate = wxPyBeginAllowThreads();
16995 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16996
16997 wxPyEndAllowThreads(__tstate);
16998 if (PyErr_Occurred()) SWIG_fail;
16999 }
17000 {
17001 wxSize * resultptr;
17002 resultptr = new wxSize((wxSize &)(result));
17003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17004 }
17005 {
17006 if (temp1)
17007 delete arg1;
17008 }
17009 return resultobj;
17010 fail:
17011 {
17012 if (temp1)
17013 delete arg1;
17014 }
17015 return NULL;
17016 }
17017
17018
17019 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17020 PyObject *resultobj;
17021 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17022 PyObject * obj0 = 0 ;
17023 char *kwnames[] = {
17024 (char *) "self", NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17029 if (SWIG_arg_fail(1)) SWIG_fail;
17030 {
17031 PyThreadState* __tstate = wxPyBeginAllowThreads();
17032 wxPyArtProvider_Destroy(arg1);
17033
17034 wxPyEndAllowThreads(__tstate);
17035 if (PyErr_Occurred()) SWIG_fail;
17036 }
17037 Py_INCREF(Py_None); resultobj = Py_None;
17038 return resultobj;
17039 fail:
17040 return NULL;
17041 }
17042
17043
17044 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17045 PyObject *obj;
17046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17047 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17048 Py_INCREF(obj);
17049 return Py_BuildValue((char *)"");
17050 }
17051 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj;
17053 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17054 PyObject * obj0 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "self", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 {
17063 PyThreadState* __tstate = wxPyBeginAllowThreads();
17064 delete arg1;
17065
17066 wxPyEndAllowThreads(__tstate);
17067 if (PyErr_Occurred()) SWIG_fail;
17068 }
17069 Py_INCREF(Py_None); resultobj = Py_None;
17070 return resultobj;
17071 fail:
17072 return NULL;
17073 }
17074
17075
17076 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17077 PyObject *resultobj;
17078 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17079 wxConfigBase *result;
17080 PyObject * obj0 = 0 ;
17081 char *kwnames[] = {
17082 (char *) "config", NULL
17083 };
17084
17085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17087 if (SWIG_arg_fail(1)) SWIG_fail;
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17091
17092 wxPyEndAllowThreads(__tstate);
17093 if (PyErr_Occurred()) SWIG_fail;
17094 }
17095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17096 return resultobj;
17097 fail:
17098 return NULL;
17099 }
17100
17101
17102 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17103 PyObject *resultobj;
17104 bool arg1 = (bool) true ;
17105 wxConfigBase *result;
17106 PyObject * obj0 = 0 ;
17107 char *kwnames[] = {
17108 (char *) "createOnDemand", NULL
17109 };
17110
17111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17112 if (obj0) {
17113 {
17114 arg1 = (bool)(SWIG_As_bool(obj0));
17115 if (SWIG_arg_fail(1)) SWIG_fail;
17116 }
17117 }
17118 {
17119 PyThreadState* __tstate = wxPyBeginAllowThreads();
17120 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17121
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17133 PyObject *resultobj;
17134 wxConfigBase *result;
17135 char *kwnames[] = {
17136 NULL
17137 };
17138
17139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 result = (wxConfigBase *)wxConfigBase::Create();
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 char *kwnames[] = {
17157 NULL
17158 };
17159
17160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 wxConfigBase::DontCreateOnDemand();
17164
17165 wxPyEndAllowThreads(__tstate);
17166 if (PyErr_Occurred()) SWIG_fail;
17167 }
17168 Py_INCREF(Py_None); resultobj = Py_None;
17169 return resultobj;
17170 fail:
17171 return NULL;
17172 }
17173
17174
17175 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17176 PyObject *resultobj;
17177 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17178 wxString *arg2 = 0 ;
17179 bool temp2 = false ;
17180 PyObject * obj0 = 0 ;
17181 PyObject * obj1 = 0 ;
17182 char *kwnames[] = {
17183 (char *) "self",(char *) "path", NULL
17184 };
17185
17186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17188 if (SWIG_arg_fail(1)) SWIG_fail;
17189 {
17190 arg2 = wxString_in_helper(obj1);
17191 if (arg2 == NULL) SWIG_fail;
17192 temp2 = true;
17193 }
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 (arg1)->SetPath((wxString const &)*arg2);
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 Py_INCREF(Py_None); resultobj = Py_None;
17202 {
17203 if (temp2)
17204 delete arg2;
17205 }
17206 return resultobj;
17207 fail:
17208 {
17209 if (temp2)
17210 delete arg2;
17211 }
17212 return NULL;
17213 }
17214
17215
17216 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17217 PyObject *resultobj;
17218 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17219 wxString *result;
17220 PyObject * obj0 = 0 ;
17221 char *kwnames[] = {
17222 (char *) "self", NULL
17223 };
17224
17225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17227 if (SWIG_arg_fail(1)) SWIG_fail;
17228 {
17229 PyThreadState* __tstate = wxPyBeginAllowThreads();
17230 {
17231 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17232 result = (wxString *) &_result_ref;
17233 }
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 {
17239 #if wxUSE_UNICODE
17240 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17241 #else
17242 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17243 #endif
17244 }
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj;
17253 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17254 PyObject *result;
17255 PyObject * obj0 = 0 ;
17256 char *kwnames[] = {
17257 (char *) "self", NULL
17258 };
17259
17260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17262 if (SWIG_arg_fail(1)) SWIG_fail;
17263 {
17264 PyThreadState* __tstate = wxPyBeginAllowThreads();
17265 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17266
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = result;
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj;
17279 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17280 long arg2 ;
17281 PyObject *result;
17282 PyObject * obj0 = 0 ;
17283 PyObject * obj1 = 0 ;
17284 char *kwnames[] = {
17285 (char *) "self",(char *) "index", NULL
17286 };
17287
17288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17290 if (SWIG_arg_fail(1)) SWIG_fail;
17291 {
17292 arg2 = (long)(SWIG_As_long(obj1));
17293 if (SWIG_arg_fail(2)) SWIG_fail;
17294 }
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17298
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 resultobj = result;
17303 return resultobj;
17304 fail:
17305 return NULL;
17306 }
17307
17308
17309 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj;
17311 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17312 PyObject *result;
17313 PyObject * obj0 = 0 ;
17314 char *kwnames[] = {
17315 (char *) "self", NULL
17316 };
17317
17318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17320 if (SWIG_arg_fail(1)) SWIG_fail;
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17324
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = result;
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17338 long arg2 ;
17339 PyObject *result;
17340 PyObject * obj0 = 0 ;
17341 PyObject * obj1 = 0 ;
17342 char *kwnames[] = {
17343 (char *) "self",(char *) "index", NULL
17344 };
17345
17346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17348 if (SWIG_arg_fail(1)) SWIG_fail;
17349 {
17350 arg2 = (long)(SWIG_As_long(obj1));
17351 if (SWIG_arg_fail(2)) SWIG_fail;
17352 }
17353 {
17354 PyThreadState* __tstate = wxPyBeginAllowThreads();
17355 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17356
17357 wxPyEndAllowThreads(__tstate);
17358 if (PyErr_Occurred()) SWIG_fail;
17359 }
17360 resultobj = result;
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17368 PyObject *resultobj;
17369 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17370 bool arg2 = (bool) false ;
17371 size_t result;
17372 PyObject * obj0 = 0 ;
17373 PyObject * obj1 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self",(char *) "recursive", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 if (obj1) {
17382 {
17383 arg2 = (bool)(SWIG_As_bool(obj1));
17384 if (SWIG_arg_fail(2)) SWIG_fail;
17385 }
17386 }
17387 {
17388 PyThreadState* __tstate = wxPyBeginAllowThreads();
17389 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17390
17391 wxPyEndAllowThreads(__tstate);
17392 if (PyErr_Occurred()) SWIG_fail;
17393 }
17394 {
17395 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17396 }
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj;
17405 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17406 bool arg2 = (bool) false ;
17407 size_t result;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 char *kwnames[] = {
17411 (char *) "self",(char *) "recursive", NULL
17412 };
17413
17414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17416 if (SWIG_arg_fail(1)) SWIG_fail;
17417 if (obj1) {
17418 {
17419 arg2 = (bool)(SWIG_As_bool(obj1));
17420 if (SWIG_arg_fail(2)) SWIG_fail;
17421 }
17422 }
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17426
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 {
17431 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17432 }
17433 return resultobj;
17434 fail:
17435 return NULL;
17436 }
17437
17438
17439 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj;
17441 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17442 wxString *arg2 = 0 ;
17443 bool result;
17444 bool temp2 = false ;
17445 PyObject * obj0 = 0 ;
17446 PyObject * obj1 = 0 ;
17447 char *kwnames[] = {
17448 (char *) "self",(char *) "name", NULL
17449 };
17450
17451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17462
17463 wxPyEndAllowThreads(__tstate);
17464 if (PyErr_Occurred()) SWIG_fail;
17465 }
17466 {
17467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17468 }
17469 {
17470 if (temp2)
17471 delete arg2;
17472 }
17473 return resultobj;
17474 fail:
17475 {
17476 if (temp2)
17477 delete arg2;
17478 }
17479 return NULL;
17480 }
17481
17482
17483 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17484 PyObject *resultobj;
17485 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17486 wxString *arg2 = 0 ;
17487 bool result;
17488 bool temp2 = false ;
17489 PyObject * obj0 = 0 ;
17490 PyObject * obj1 = 0 ;
17491 char *kwnames[] = {
17492 (char *) "self",(char *) "name", NULL
17493 };
17494
17495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17497 if (SWIG_arg_fail(1)) SWIG_fail;
17498 {
17499 arg2 = wxString_in_helper(obj1);
17500 if (arg2 == NULL) SWIG_fail;
17501 temp2 = true;
17502 }
17503 {
17504 PyThreadState* __tstate = wxPyBeginAllowThreads();
17505 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17506
17507 wxPyEndAllowThreads(__tstate);
17508 if (PyErr_Occurred()) SWIG_fail;
17509 }
17510 {
17511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17512 }
17513 {
17514 if (temp2)
17515 delete arg2;
17516 }
17517 return resultobj;
17518 fail:
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17530 wxString *arg2 = 0 ;
17531 bool result;
17532 bool temp2 = false ;
17533 PyObject * obj0 = 0 ;
17534 PyObject * obj1 = 0 ;
17535 char *kwnames[] = {
17536 (char *) "self",(char *) "name", NULL
17537 };
17538
17539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17541 if (SWIG_arg_fail(1)) SWIG_fail;
17542 {
17543 arg2 = wxString_in_helper(obj1);
17544 if (arg2 == NULL) SWIG_fail;
17545 temp2 = true;
17546 }
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17550
17551 wxPyEndAllowThreads(__tstate);
17552 if (PyErr_Occurred()) SWIG_fail;
17553 }
17554 {
17555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17556 }
17557 {
17558 if (temp2)
17559 delete arg2;
17560 }
17561 return resultobj;
17562 fail:
17563 {
17564 if (temp2)
17565 delete arg2;
17566 }
17567 return NULL;
17568 }
17569
17570
17571 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj;
17573 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17574 wxString *arg2 = 0 ;
17575 wxConfigBase::EntryType result;
17576 bool temp2 = false ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 char *kwnames[] = {
17580 (char *) "self",(char *) "name", NULL
17581 };
17582
17583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17585 if (SWIG_arg_fail(1)) SWIG_fail;
17586 {
17587 arg2 = wxString_in_helper(obj1);
17588 if (arg2 == NULL) SWIG_fail;
17589 temp2 = true;
17590 }
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17594
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 resultobj = SWIG_From_int((result));
17599 {
17600 if (temp2)
17601 delete arg2;
17602 }
17603 return resultobj;
17604 fail:
17605 {
17606 if (temp2)
17607 delete arg2;
17608 }
17609 return NULL;
17610 }
17611
17612
17613 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj;
17615 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17616 wxString *arg2 = 0 ;
17617 wxString const &arg3_defvalue = wxPyEmptyString ;
17618 wxString *arg3 = (wxString *) &arg3_defvalue ;
17619 wxString result;
17620 bool temp2 = false ;
17621 bool temp3 = false ;
17622 PyObject * obj0 = 0 ;
17623 PyObject * obj1 = 0 ;
17624 PyObject * obj2 = 0 ;
17625 char *kwnames[] = {
17626 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17627 };
17628
17629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17631 if (SWIG_arg_fail(1)) SWIG_fail;
17632 {
17633 arg2 = wxString_in_helper(obj1);
17634 if (arg2 == NULL) SWIG_fail;
17635 temp2 = true;
17636 }
17637 if (obj2) {
17638 {
17639 arg3 = wxString_in_helper(obj2);
17640 if (arg3 == NULL) SWIG_fail;
17641 temp3 = true;
17642 }
17643 }
17644 {
17645 PyThreadState* __tstate = wxPyBeginAllowThreads();
17646 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17647
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 {
17652 #if wxUSE_UNICODE
17653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17654 #else
17655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17656 #endif
17657 }
17658 {
17659 if (temp2)
17660 delete arg2;
17661 }
17662 {
17663 if (temp3)
17664 delete arg3;
17665 }
17666 return resultobj;
17667 fail:
17668 {
17669 if (temp2)
17670 delete arg2;
17671 }
17672 {
17673 if (temp3)
17674 delete arg3;
17675 }
17676 return NULL;
17677 }
17678
17679
17680 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17681 PyObject *resultobj;
17682 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17683 wxString *arg2 = 0 ;
17684 long arg3 = (long) 0 ;
17685 long result;
17686 bool temp2 = false ;
17687 PyObject * obj0 = 0 ;
17688 PyObject * obj1 = 0 ;
17689 PyObject * obj2 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17696 if (SWIG_arg_fail(1)) SWIG_fail;
17697 {
17698 arg2 = wxString_in_helper(obj1);
17699 if (arg2 == NULL) SWIG_fail;
17700 temp2 = true;
17701 }
17702 if (obj2) {
17703 {
17704 arg3 = (long)(SWIG_As_long(obj2));
17705 if (SWIG_arg_fail(3)) SWIG_fail;
17706 }
17707 }
17708 {
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17711
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 {
17716 resultobj = SWIG_From_long((long)(result));
17717 }
17718 {
17719 if (temp2)
17720 delete arg2;
17721 }
17722 return resultobj;
17723 fail:
17724 {
17725 if (temp2)
17726 delete arg2;
17727 }
17728 return NULL;
17729 }
17730
17731
17732 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj;
17734 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17735 wxString *arg2 = 0 ;
17736 double arg3 = (double) 0.0 ;
17737 double result;
17738 bool temp2 = false ;
17739 PyObject * obj0 = 0 ;
17740 PyObject * obj1 = 0 ;
17741 PyObject * obj2 = 0 ;
17742 char *kwnames[] = {
17743 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17744 };
17745
17746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 {
17750 arg2 = wxString_in_helper(obj1);
17751 if (arg2 == NULL) SWIG_fail;
17752 temp2 = true;
17753 }
17754 if (obj2) {
17755 {
17756 arg3 = (double)(SWIG_As_double(obj2));
17757 if (SWIG_arg_fail(3)) SWIG_fail;
17758 }
17759 }
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17763
17764 wxPyEndAllowThreads(__tstate);
17765 if (PyErr_Occurred()) SWIG_fail;
17766 }
17767 {
17768 resultobj = SWIG_From_double((double)(result));
17769 }
17770 {
17771 if (temp2)
17772 delete arg2;
17773 }
17774 return resultobj;
17775 fail:
17776 {
17777 if (temp2)
17778 delete arg2;
17779 }
17780 return NULL;
17781 }
17782
17783
17784 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17785 PyObject *resultobj;
17786 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17787 wxString *arg2 = 0 ;
17788 bool arg3 = (bool) false ;
17789 bool result;
17790 bool temp2 = false ;
17791 PyObject * obj0 = 0 ;
17792 PyObject * obj1 = 0 ;
17793 PyObject * obj2 = 0 ;
17794 char *kwnames[] = {
17795 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17796 };
17797
17798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(1)) SWIG_fail;
17801 {
17802 arg2 = wxString_in_helper(obj1);
17803 if (arg2 == NULL) SWIG_fail;
17804 temp2 = true;
17805 }
17806 if (obj2) {
17807 {
17808 arg3 = (bool)(SWIG_As_bool(obj2));
17809 if (SWIG_arg_fail(3)) SWIG_fail;
17810 }
17811 }
17812 {
17813 PyThreadState* __tstate = wxPyBeginAllowThreads();
17814 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17815
17816 wxPyEndAllowThreads(__tstate);
17817 if (PyErr_Occurred()) SWIG_fail;
17818 }
17819 {
17820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17821 }
17822 {
17823 if (temp2)
17824 delete arg2;
17825 }
17826 return resultobj;
17827 fail:
17828 {
17829 if (temp2)
17830 delete arg2;
17831 }
17832 return NULL;
17833 }
17834
17835
17836 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17837 PyObject *resultobj;
17838 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17839 wxString *arg2 = 0 ;
17840 wxString *arg3 = 0 ;
17841 bool result;
17842 bool temp2 = false ;
17843 bool temp3 = false ;
17844 PyObject * obj0 = 0 ;
17845 PyObject * obj1 = 0 ;
17846 PyObject * obj2 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self",(char *) "key",(char *) "value", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 {
17855 arg2 = wxString_in_helper(obj1);
17856 if (arg2 == NULL) SWIG_fail;
17857 temp2 = true;
17858 }
17859 {
17860 arg3 = wxString_in_helper(obj2);
17861 if (arg3 == NULL) SWIG_fail;
17862 temp3 = true;
17863 }
17864 {
17865 PyThreadState* __tstate = wxPyBeginAllowThreads();
17866 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17867
17868 wxPyEndAllowThreads(__tstate);
17869 if (PyErr_Occurred()) SWIG_fail;
17870 }
17871 {
17872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17873 }
17874 {
17875 if (temp2)
17876 delete arg2;
17877 }
17878 {
17879 if (temp3)
17880 delete arg3;
17881 }
17882 return resultobj;
17883 fail:
17884 {
17885 if (temp2)
17886 delete arg2;
17887 }
17888 {
17889 if (temp3)
17890 delete arg3;
17891 }
17892 return NULL;
17893 }
17894
17895
17896 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17897 PyObject *resultobj;
17898 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17899 wxString *arg2 = 0 ;
17900 long arg3 ;
17901 bool result;
17902 bool temp2 = false ;
17903 PyObject * obj0 = 0 ;
17904 PyObject * obj1 = 0 ;
17905 PyObject * obj2 = 0 ;
17906 char *kwnames[] = {
17907 (char *) "self",(char *) "key",(char *) "value", NULL
17908 };
17909
17910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17912 if (SWIG_arg_fail(1)) SWIG_fail;
17913 {
17914 arg2 = wxString_in_helper(obj1);
17915 if (arg2 == NULL) SWIG_fail;
17916 temp2 = true;
17917 }
17918 {
17919 arg3 = (long)(SWIG_As_long(obj2));
17920 if (SWIG_arg_fail(3)) SWIG_fail;
17921 }
17922 {
17923 PyThreadState* __tstate = wxPyBeginAllowThreads();
17924 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17925
17926 wxPyEndAllowThreads(__tstate);
17927 if (PyErr_Occurred()) SWIG_fail;
17928 }
17929 {
17930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17931 }
17932 {
17933 if (temp2)
17934 delete arg2;
17935 }
17936 return resultobj;
17937 fail:
17938 {
17939 if (temp2)
17940 delete arg2;
17941 }
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj;
17948 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17949 wxString *arg2 = 0 ;
17950 double arg3 ;
17951 bool result;
17952 bool temp2 = false ;
17953 PyObject * obj0 = 0 ;
17954 PyObject * obj1 = 0 ;
17955 PyObject * obj2 = 0 ;
17956 char *kwnames[] = {
17957 (char *) "self",(char *) "key",(char *) "value", NULL
17958 };
17959
17960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17962 if (SWIG_arg_fail(1)) SWIG_fail;
17963 {
17964 arg2 = wxString_in_helper(obj1);
17965 if (arg2 == NULL) SWIG_fail;
17966 temp2 = true;
17967 }
17968 {
17969 arg3 = (double)(SWIG_As_double(obj2));
17970 if (SWIG_arg_fail(3)) SWIG_fail;
17971 }
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17975
17976 wxPyEndAllowThreads(__tstate);
17977 if (PyErr_Occurred()) SWIG_fail;
17978 }
17979 {
17980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17981 }
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_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj;
17998 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17999 wxString *arg2 = 0 ;
18000 bool arg3 ;
18001 bool result;
18002 bool temp2 = false ;
18003 PyObject * obj0 = 0 ;
18004 PyObject * obj1 = 0 ;
18005 PyObject * obj2 = 0 ;
18006 char *kwnames[] = {
18007 (char *) "self",(char *) "key",(char *) "value", NULL
18008 };
18009
18010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18012 if (SWIG_arg_fail(1)) SWIG_fail;
18013 {
18014 arg2 = wxString_in_helper(obj1);
18015 if (arg2 == NULL) SWIG_fail;
18016 temp2 = true;
18017 }
18018 {
18019 arg3 = (bool)(SWIG_As_bool(obj2));
18020 if (SWIG_arg_fail(3)) SWIG_fail;
18021 }
18022 {
18023 PyThreadState* __tstate = wxPyBeginAllowThreads();
18024 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18025
18026 wxPyEndAllowThreads(__tstate);
18027 if (PyErr_Occurred()) SWIG_fail;
18028 }
18029 {
18030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18031 }
18032 {
18033 if (temp2)
18034 delete arg2;
18035 }
18036 return resultobj;
18037 fail:
18038 {
18039 if (temp2)
18040 delete arg2;
18041 }
18042 return NULL;
18043 }
18044
18045
18046 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18047 PyObject *resultobj;
18048 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18049 bool arg2 = (bool) false ;
18050 bool result;
18051 PyObject * obj0 = 0 ;
18052 PyObject * obj1 = 0 ;
18053 char *kwnames[] = {
18054 (char *) "self",(char *) "currentOnly", NULL
18055 };
18056
18057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18059 if (SWIG_arg_fail(1)) SWIG_fail;
18060 if (obj1) {
18061 {
18062 arg2 = (bool)(SWIG_As_bool(obj1));
18063 if (SWIG_arg_fail(2)) SWIG_fail;
18064 }
18065 }
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 result = (bool)(arg1)->Flush(arg2);
18069
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 {
18074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18075 }
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj;
18084 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18085 wxString *arg2 = 0 ;
18086 wxString *arg3 = 0 ;
18087 bool result;
18088 bool temp2 = false ;
18089 bool temp3 = false ;
18090 PyObject * obj0 = 0 ;
18091 PyObject * obj1 = 0 ;
18092 PyObject * obj2 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 {
18101 arg2 = wxString_in_helper(obj1);
18102 if (arg2 == NULL) SWIG_fail;
18103 temp2 = true;
18104 }
18105 {
18106 arg3 = wxString_in_helper(obj2);
18107 if (arg3 == NULL) SWIG_fail;
18108 temp3 = true;
18109 }
18110 {
18111 PyThreadState* __tstate = wxPyBeginAllowThreads();
18112 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18113
18114 wxPyEndAllowThreads(__tstate);
18115 if (PyErr_Occurred()) SWIG_fail;
18116 }
18117 {
18118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18119 }
18120 {
18121 if (temp2)
18122 delete arg2;
18123 }
18124 {
18125 if (temp3)
18126 delete arg3;
18127 }
18128 return resultobj;
18129 fail:
18130 {
18131 if (temp2)
18132 delete arg2;
18133 }
18134 {
18135 if (temp3)
18136 delete arg3;
18137 }
18138 return NULL;
18139 }
18140
18141
18142 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18143 PyObject *resultobj;
18144 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18145 wxString *arg2 = 0 ;
18146 wxString *arg3 = 0 ;
18147 bool result;
18148 bool temp2 = false ;
18149 bool temp3 = false ;
18150 PyObject * obj0 = 0 ;
18151 PyObject * obj1 = 0 ;
18152 PyObject * obj2 = 0 ;
18153 char *kwnames[] = {
18154 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18155 };
18156
18157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18159 if (SWIG_arg_fail(1)) SWIG_fail;
18160 {
18161 arg2 = wxString_in_helper(obj1);
18162 if (arg2 == NULL) SWIG_fail;
18163 temp2 = true;
18164 }
18165 {
18166 arg3 = wxString_in_helper(obj2);
18167 if (arg3 == NULL) SWIG_fail;
18168 temp3 = true;
18169 }
18170 {
18171 PyThreadState* __tstate = wxPyBeginAllowThreads();
18172 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18173
18174 wxPyEndAllowThreads(__tstate);
18175 if (PyErr_Occurred()) SWIG_fail;
18176 }
18177 {
18178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18179 }
18180 {
18181 if (temp2)
18182 delete arg2;
18183 }
18184 {
18185 if (temp3)
18186 delete arg3;
18187 }
18188 return resultobj;
18189 fail:
18190 {
18191 if (temp2)
18192 delete arg2;
18193 }
18194 {
18195 if (temp3)
18196 delete arg3;
18197 }
18198 return NULL;
18199 }
18200
18201
18202 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj;
18204 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18205 wxString *arg2 = 0 ;
18206 bool arg3 = (bool) true ;
18207 bool result;
18208 bool temp2 = false ;
18209 PyObject * obj0 = 0 ;
18210 PyObject * obj1 = 0 ;
18211 PyObject * obj2 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18218 if (SWIG_arg_fail(1)) SWIG_fail;
18219 {
18220 arg2 = wxString_in_helper(obj1);
18221 if (arg2 == NULL) SWIG_fail;
18222 temp2 = true;
18223 }
18224 if (obj2) {
18225 {
18226 arg3 = (bool)(SWIG_As_bool(obj2));
18227 if (SWIG_arg_fail(3)) SWIG_fail;
18228 }
18229 }
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18233
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 {
18238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18239 }
18240 {
18241 if (temp2)
18242 delete arg2;
18243 }
18244 return resultobj;
18245 fail:
18246 {
18247 if (temp2)
18248 delete arg2;
18249 }
18250 return NULL;
18251 }
18252
18253
18254 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18255 PyObject *resultobj;
18256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18257 wxString *arg2 = 0 ;
18258 bool result;
18259 bool temp2 = false ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char *kwnames[] = {
18263 (char *) "self",(char *) "key", NULL
18264 };
18265
18266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18268 if (SWIG_arg_fail(1)) SWIG_fail;
18269 {
18270 arg2 = wxString_in_helper(obj1);
18271 if (arg2 == NULL) SWIG_fail;
18272 temp2 = true;
18273 }
18274 {
18275 PyThreadState* __tstate = wxPyBeginAllowThreads();
18276 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18277
18278 wxPyEndAllowThreads(__tstate);
18279 if (PyErr_Occurred()) SWIG_fail;
18280 }
18281 {
18282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18283 }
18284 {
18285 if (temp2)
18286 delete arg2;
18287 }
18288 return resultobj;
18289 fail:
18290 {
18291 if (temp2)
18292 delete arg2;
18293 }
18294 return NULL;
18295 }
18296
18297
18298 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj;
18300 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18301 bool result;
18302 PyObject * obj0 = 0 ;
18303 char *kwnames[] = {
18304 (char *) "self", NULL
18305 };
18306
18307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18309 if (SWIG_arg_fail(1)) SWIG_fail;
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (bool)(arg1)->DeleteAll();
18313
18314 wxPyEndAllowThreads(__tstate);
18315 if (PyErr_Occurred()) SWIG_fail;
18316 }
18317 {
18318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18319 }
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj;
18328 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18329 bool arg2 = (bool) true ;
18330 PyObject * obj0 = 0 ;
18331 PyObject * obj1 = 0 ;
18332 char *kwnames[] = {
18333 (char *) "self",(char *) "doIt", NULL
18334 };
18335
18336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18338 if (SWIG_arg_fail(1)) SWIG_fail;
18339 if (obj1) {
18340 {
18341 arg2 = (bool)(SWIG_As_bool(obj1));
18342 if (SWIG_arg_fail(2)) SWIG_fail;
18343 }
18344 }
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 (arg1)->SetExpandEnvVars(arg2);
18348
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 Py_INCREF(Py_None); resultobj = Py_None;
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj;
18361 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18362 bool result;
18363 PyObject * obj0 = 0 ;
18364 char *kwnames[] = {
18365 (char *) "self", NULL
18366 };
18367
18368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18370 if (SWIG_arg_fail(1)) SWIG_fail;
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18374
18375 wxPyEndAllowThreads(__tstate);
18376 if (PyErr_Occurred()) SWIG_fail;
18377 }
18378 {
18379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18380 }
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj;
18389 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18390 bool arg2 = (bool) true ;
18391 PyObject * obj0 = 0 ;
18392 PyObject * obj1 = 0 ;
18393 char *kwnames[] = {
18394 (char *) "self",(char *) "doIt", NULL
18395 };
18396
18397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18399 if (SWIG_arg_fail(1)) SWIG_fail;
18400 if (obj1) {
18401 {
18402 arg2 = (bool)(SWIG_As_bool(obj1));
18403 if (SWIG_arg_fail(2)) SWIG_fail;
18404 }
18405 }
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 (arg1)->SetRecordDefaults(arg2);
18409
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 Py_INCREF(Py_None); resultobj = Py_None;
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj;
18422 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18423 bool result;
18424 PyObject * obj0 = 0 ;
18425 char *kwnames[] = {
18426 (char *) "self", NULL
18427 };
18428
18429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18431 if (SWIG_arg_fail(1)) SWIG_fail;
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18435
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 {
18440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18441 }
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj;
18450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18451 wxString *arg2 = 0 ;
18452 wxString result;
18453 bool temp2 = false ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self",(char *) "str", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 arg2 = wxString_in_helper(obj1);
18465 if (arg2 == NULL) SWIG_fail;
18466 temp2 = true;
18467 }
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18471
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 {
18476 #if wxUSE_UNICODE
18477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18478 #else
18479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18480 #endif
18481 }
18482 {
18483 if (temp2)
18484 delete arg2;
18485 }
18486 return resultobj;
18487 fail:
18488 {
18489 if (temp2)
18490 delete arg2;
18491 }
18492 return NULL;
18493 }
18494
18495
18496 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj;
18498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18499 wxString result;
18500 PyObject * obj0 = 0 ;
18501 char *kwnames[] = {
18502 (char *) "self", NULL
18503 };
18504
18505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18507 if (SWIG_arg_fail(1)) SWIG_fail;
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 result = ((wxConfigBase const *)arg1)->GetAppName();
18511
18512 wxPyEndAllowThreads(__tstate);
18513 if (PyErr_Occurred()) SWIG_fail;
18514 }
18515 {
18516 #if wxUSE_UNICODE
18517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18518 #else
18519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18520 #endif
18521 }
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18529 PyObject *resultobj;
18530 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18531 wxString result;
18532 PyObject * obj0 = 0 ;
18533 char *kwnames[] = {
18534 (char *) "self", NULL
18535 };
18536
18537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18539 if (SWIG_arg_fail(1)) SWIG_fail;
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = ((wxConfigBase const *)arg1)->GetVendorName();
18543
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 {
18548 #if wxUSE_UNICODE
18549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18550 #else
18551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18552 #endif
18553 }
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18561 PyObject *resultobj;
18562 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18563 wxString *arg2 = 0 ;
18564 bool temp2 = false ;
18565 PyObject * obj0 = 0 ;
18566 PyObject * obj1 = 0 ;
18567 char *kwnames[] = {
18568 (char *) "self",(char *) "appName", NULL
18569 };
18570
18571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18573 if (SWIG_arg_fail(1)) SWIG_fail;
18574 {
18575 arg2 = wxString_in_helper(obj1);
18576 if (arg2 == NULL) SWIG_fail;
18577 temp2 = true;
18578 }
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 (arg1)->SetAppName((wxString const &)*arg2);
18582
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 Py_INCREF(Py_None); resultobj = Py_None;
18587 {
18588 if (temp2)
18589 delete arg2;
18590 }
18591 return resultobj;
18592 fail:
18593 {
18594 if (temp2)
18595 delete arg2;
18596 }
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18604 wxString *arg2 = 0 ;
18605 bool temp2 = false ;
18606 PyObject * obj0 = 0 ;
18607 PyObject * obj1 = 0 ;
18608 char *kwnames[] = {
18609 (char *) "self",(char *) "vendorName", NULL
18610 };
18611
18612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18614 if (SWIG_arg_fail(1)) SWIG_fail;
18615 {
18616 arg2 = wxString_in_helper(obj1);
18617 if (arg2 == NULL) SWIG_fail;
18618 temp2 = true;
18619 }
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 (arg1)->SetVendorName((wxString const &)*arg2);
18623
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 Py_INCREF(Py_None); resultobj = Py_None;
18628 {
18629 if (temp2)
18630 delete arg2;
18631 }
18632 return resultobj;
18633 fail:
18634 {
18635 if (temp2)
18636 delete arg2;
18637 }
18638 return NULL;
18639 }
18640
18641
18642 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18643 PyObject *resultobj;
18644 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18645 long arg2 ;
18646 PyObject * obj0 = 0 ;
18647 PyObject * obj1 = 0 ;
18648 char *kwnames[] = {
18649 (char *) "self",(char *) "style", NULL
18650 };
18651
18652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18654 if (SWIG_arg_fail(1)) SWIG_fail;
18655 {
18656 arg2 = (long)(SWIG_As_long(obj1));
18657 if (SWIG_arg_fail(2)) SWIG_fail;
18658 }
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 (arg1)->SetStyle(arg2);
18662
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 Py_INCREF(Py_None); resultobj = Py_None;
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj;
18675 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18676 long result;
18677 PyObject * obj0 = 0 ;
18678 char *kwnames[] = {
18679 (char *) "self", NULL
18680 };
18681
18682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18684 if (SWIG_arg_fail(1)) SWIG_fail;
18685 {
18686 PyThreadState* __tstate = wxPyBeginAllowThreads();
18687 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18688
18689 wxPyEndAllowThreads(__tstate);
18690 if (PyErr_Occurred()) SWIG_fail;
18691 }
18692 {
18693 resultobj = SWIG_From_long((long)(result));
18694 }
18695 return resultobj;
18696 fail:
18697 return NULL;
18698 }
18699
18700
18701 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18702 PyObject *obj;
18703 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18704 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18705 Py_INCREF(obj);
18706 return Py_BuildValue((char *)"");
18707 }
18708 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18709 PyObject *resultobj;
18710 wxString const &arg1_defvalue = wxPyEmptyString ;
18711 wxString *arg1 = (wxString *) &arg1_defvalue ;
18712 wxString const &arg2_defvalue = wxPyEmptyString ;
18713 wxString *arg2 = (wxString *) &arg2_defvalue ;
18714 wxString const &arg3_defvalue = wxPyEmptyString ;
18715 wxString *arg3 = (wxString *) &arg3_defvalue ;
18716 wxString const &arg4_defvalue = wxPyEmptyString ;
18717 wxString *arg4 = (wxString *) &arg4_defvalue ;
18718 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18719 wxConfig *result;
18720 bool temp1 = false ;
18721 bool temp2 = false ;
18722 bool temp3 = false ;
18723 bool temp4 = false ;
18724 PyObject * obj0 = 0 ;
18725 PyObject * obj1 = 0 ;
18726 PyObject * obj2 = 0 ;
18727 PyObject * obj3 = 0 ;
18728 PyObject * obj4 = 0 ;
18729 char *kwnames[] = {
18730 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18731 };
18732
18733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18734 if (obj0) {
18735 {
18736 arg1 = wxString_in_helper(obj0);
18737 if (arg1 == NULL) SWIG_fail;
18738 temp1 = true;
18739 }
18740 }
18741 if (obj1) {
18742 {
18743 arg2 = wxString_in_helper(obj1);
18744 if (arg2 == NULL) SWIG_fail;
18745 temp2 = true;
18746 }
18747 }
18748 if (obj2) {
18749 {
18750 arg3 = wxString_in_helper(obj2);
18751 if (arg3 == NULL) SWIG_fail;
18752 temp3 = true;
18753 }
18754 }
18755 if (obj3) {
18756 {
18757 arg4 = wxString_in_helper(obj3);
18758 if (arg4 == NULL) SWIG_fail;
18759 temp4 = true;
18760 }
18761 }
18762 if (obj4) {
18763 {
18764 arg5 = (long)(SWIG_As_long(obj4));
18765 if (SWIG_arg_fail(5)) SWIG_fail;
18766 }
18767 }
18768 {
18769 PyThreadState* __tstate = wxPyBeginAllowThreads();
18770 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18771
18772 wxPyEndAllowThreads(__tstate);
18773 if (PyErr_Occurred()) SWIG_fail;
18774 }
18775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18776 {
18777 if (temp1)
18778 delete arg1;
18779 }
18780 {
18781 if (temp2)
18782 delete arg2;
18783 }
18784 {
18785 if (temp3)
18786 delete arg3;
18787 }
18788 {
18789 if (temp4)
18790 delete arg4;
18791 }
18792 return resultobj;
18793 fail:
18794 {
18795 if (temp1)
18796 delete arg1;
18797 }
18798 {
18799 if (temp2)
18800 delete arg2;
18801 }
18802 {
18803 if (temp3)
18804 delete arg3;
18805 }
18806 {
18807 if (temp4)
18808 delete arg4;
18809 }
18810 return NULL;
18811 }
18812
18813
18814 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj;
18816 wxConfig *arg1 = (wxConfig *) 0 ;
18817 PyObject * obj0 = 0 ;
18818 char *kwnames[] = {
18819 (char *) "self", NULL
18820 };
18821
18822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18824 if (SWIG_arg_fail(1)) SWIG_fail;
18825 {
18826 PyThreadState* __tstate = wxPyBeginAllowThreads();
18827 delete arg1;
18828
18829 wxPyEndAllowThreads(__tstate);
18830 if (PyErr_Occurred()) SWIG_fail;
18831 }
18832 Py_INCREF(Py_None); resultobj = Py_None;
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18840 PyObject *obj;
18841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18842 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18843 Py_INCREF(obj);
18844 return Py_BuildValue((char *)"");
18845 }
18846 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj;
18848 wxString const &arg1_defvalue = wxPyEmptyString ;
18849 wxString *arg1 = (wxString *) &arg1_defvalue ;
18850 wxString const &arg2_defvalue = wxPyEmptyString ;
18851 wxString *arg2 = (wxString *) &arg2_defvalue ;
18852 wxString const &arg3_defvalue = wxPyEmptyString ;
18853 wxString *arg3 = (wxString *) &arg3_defvalue ;
18854 wxString const &arg4_defvalue = wxPyEmptyString ;
18855 wxString *arg4 = (wxString *) &arg4_defvalue ;
18856 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18857 wxFileConfig *result;
18858 bool temp1 = false ;
18859 bool temp2 = false ;
18860 bool temp3 = false ;
18861 bool temp4 = false ;
18862 PyObject * obj0 = 0 ;
18863 PyObject * obj1 = 0 ;
18864 PyObject * obj2 = 0 ;
18865 PyObject * obj3 = 0 ;
18866 PyObject * obj4 = 0 ;
18867 char *kwnames[] = {
18868 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18869 };
18870
18871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18872 if (obj0) {
18873 {
18874 arg1 = wxString_in_helper(obj0);
18875 if (arg1 == NULL) SWIG_fail;
18876 temp1 = true;
18877 }
18878 }
18879 if (obj1) {
18880 {
18881 arg2 = wxString_in_helper(obj1);
18882 if (arg2 == NULL) SWIG_fail;
18883 temp2 = true;
18884 }
18885 }
18886 if (obj2) {
18887 {
18888 arg3 = wxString_in_helper(obj2);
18889 if (arg3 == NULL) SWIG_fail;
18890 temp3 = true;
18891 }
18892 }
18893 if (obj3) {
18894 {
18895 arg4 = wxString_in_helper(obj3);
18896 if (arg4 == NULL) SWIG_fail;
18897 temp4 = true;
18898 }
18899 }
18900 if (obj4) {
18901 {
18902 arg5 = (long)(SWIG_As_long(obj4));
18903 if (SWIG_arg_fail(5)) SWIG_fail;
18904 }
18905 }
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18909
18910 wxPyEndAllowThreads(__tstate);
18911 if (PyErr_Occurred()) SWIG_fail;
18912 }
18913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18914 {
18915 if (temp1)
18916 delete arg1;
18917 }
18918 {
18919 if (temp2)
18920 delete arg2;
18921 }
18922 {
18923 if (temp3)
18924 delete arg3;
18925 }
18926 {
18927 if (temp4)
18928 delete arg4;
18929 }
18930 return resultobj;
18931 fail:
18932 {
18933 if (temp1)
18934 delete arg1;
18935 }
18936 {
18937 if (temp2)
18938 delete arg2;
18939 }
18940 {
18941 if (temp3)
18942 delete arg3;
18943 }
18944 {
18945 if (temp4)
18946 delete arg4;
18947 }
18948 return NULL;
18949 }
18950
18951
18952 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj;
18954 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18955 PyObject * obj0 = 0 ;
18956 char *kwnames[] = {
18957 (char *) "self", NULL
18958 };
18959
18960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18962 if (SWIG_arg_fail(1)) SWIG_fail;
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 delete arg1;
18966
18967 wxPyEndAllowThreads(__tstate);
18968 if (PyErr_Occurred()) SWIG_fail;
18969 }
18970 Py_INCREF(Py_None); resultobj = Py_None;
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18978 PyObject *obj;
18979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18980 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18981 Py_INCREF(obj);
18982 return Py_BuildValue((char *)"");
18983 }
18984 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj;
18986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18987 wxString *arg2 = 0 ;
18988 wxConfigPathChanger *result;
18989 bool temp2 = false ;
18990 PyObject * obj0 = 0 ;
18991 PyObject * obj1 = 0 ;
18992 char *kwnames[] = {
18993 (char *) "config",(char *) "entry", NULL
18994 };
18995
18996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18998 if (SWIG_arg_fail(1)) SWIG_fail;
18999 {
19000 arg2 = wxString_in_helper(obj1);
19001 if (arg2 == NULL) SWIG_fail;
19002 temp2 = true;
19003 }
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19007
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19012 {
19013 if (temp2)
19014 delete arg2;
19015 }
19016 return resultobj;
19017 fail:
19018 {
19019 if (temp2)
19020 delete arg2;
19021 }
19022 return NULL;
19023 }
19024
19025
19026 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj;
19028 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19029 PyObject * obj0 = 0 ;
19030 char *kwnames[] = {
19031 (char *) "self", NULL
19032 };
19033
19034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19036 if (SWIG_arg_fail(1)) SWIG_fail;
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 delete arg1;
19040
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 Py_INCREF(Py_None); resultobj = Py_None;
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19052 PyObject *resultobj;
19053 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19054 wxString *result;
19055 PyObject * obj0 = 0 ;
19056 char *kwnames[] = {
19057 (char *) "self", NULL
19058 };
19059
19060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19062 if (SWIG_arg_fail(1)) SWIG_fail;
19063 {
19064 PyThreadState* __tstate = wxPyBeginAllowThreads();
19065 {
19066 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19067 result = (wxString *) &_result_ref;
19068 }
19069
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 {
19074 #if wxUSE_UNICODE
19075 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19076 #else
19077 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19078 #endif
19079 }
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19087 PyObject *obj;
19088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19089 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19090 Py_INCREF(obj);
19091 return Py_BuildValue((char *)"");
19092 }
19093 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19094 PyObject *resultobj;
19095 wxString *arg1 = 0 ;
19096 wxString result;
19097 bool temp1 = false ;
19098 PyObject * obj0 = 0 ;
19099 char *kwnames[] = {
19100 (char *) "sz", NULL
19101 };
19102
19103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19104 {
19105 arg1 = wxString_in_helper(obj0);
19106 if (arg1 == NULL) SWIG_fail;
19107 temp1 = true;
19108 }
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = wxExpandEnvVars((wxString const &)*arg1);
19112
19113 wxPyEndAllowThreads(__tstate);
19114 if (PyErr_Occurred()) SWIG_fail;
19115 }
19116 {
19117 #if wxUSE_UNICODE
19118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19119 #else
19120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19121 #endif
19122 }
19123 {
19124 if (temp1)
19125 delete arg1;
19126 }
19127 return resultobj;
19128 fail:
19129 {
19130 if (temp1)
19131 delete arg1;
19132 }
19133 return NULL;
19134 }
19135
19136
19137 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19138 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19139 return 1;
19140 }
19141
19142
19143 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19144 PyObject *pyobj;
19145
19146 {
19147 #if wxUSE_UNICODE
19148 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19149 #else
19150 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19151 #endif
19152 }
19153 return pyobj;
19154 }
19155
19156
19157 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19158 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19159 return 1;
19160 }
19161
19162
19163 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19164 PyObject *pyobj;
19165
19166 {
19167 #if wxUSE_UNICODE
19168 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19169 #else
19170 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19171 #endif
19172 }
19173 return pyobj;
19174 }
19175
19176
19177 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19178 PyObject *resultobj;
19179 wxDateTime::Country arg1 ;
19180 PyObject * obj0 = 0 ;
19181 char *kwnames[] = {
19182 (char *) "country", NULL
19183 };
19184
19185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19186 {
19187 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19188 if (SWIG_arg_fail(1)) SWIG_fail;
19189 }
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19193
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 Py_INCREF(Py_None); resultobj = Py_None;
19198 return resultobj;
19199 fail:
19200 return NULL;
19201 }
19202
19203
19204 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19205 PyObject *resultobj;
19206 wxDateTime::Country result;
19207 char *kwnames[] = {
19208 NULL
19209 };
19210
19211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19212 {
19213 PyThreadState* __tstate = wxPyBeginAllowThreads();
19214 result = (wxDateTime::Country)wxDateTime::GetCountry();
19215
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 resultobj = SWIG_From_int((result));
19220 return resultobj;
19221 fail:
19222 return NULL;
19223 }
19224
19225
19226 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19227 PyObject *resultobj;
19228 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19229 bool result;
19230 PyObject * obj0 = 0 ;
19231 char *kwnames[] = {
19232 (char *) "country", NULL
19233 };
19234
19235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19236 if (obj0) {
19237 {
19238 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19239 if (SWIG_arg_fail(1)) SWIG_fail;
19240 }
19241 }
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19245
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 {
19250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19251 }
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj;
19260 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19261 int result;
19262 PyObject * obj0 = 0 ;
19263 char *kwnames[] = {
19264 (char *) "cal", NULL
19265 };
19266
19267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19268 if (obj0) {
19269 {
19270 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19271 if (SWIG_arg_fail(1)) SWIG_fail;
19272 }
19273 }
19274 {
19275 PyThreadState* __tstate = wxPyBeginAllowThreads();
19276 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19277
19278 wxPyEndAllowThreads(__tstate);
19279 if (PyErr_Occurred()) SWIG_fail;
19280 }
19281 {
19282 resultobj = SWIG_From_int((int)(result));
19283 }
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj;
19292 int arg1 ;
19293 int result;
19294 PyObject * obj0 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "year", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19300 {
19301 arg1 = (int)(SWIG_As_int(obj0));
19302 if (SWIG_arg_fail(1)) SWIG_fail;
19303 }
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 result = (int)wxDateTime::ConvertYearToBC(arg1);
19307
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 {
19312 resultobj = SWIG_From_int((int)(result));
19313 }
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj;
19322 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19323 wxDateTime::Month result;
19324 PyObject * obj0 = 0 ;
19325 char *kwnames[] = {
19326 (char *) "cal", NULL
19327 };
19328
19329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19330 if (obj0) {
19331 {
19332 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19333 if (SWIG_arg_fail(1)) SWIG_fail;
19334 }
19335 }
19336 {
19337 PyThreadState* __tstate = wxPyBeginAllowThreads();
19338 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19339
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_From_int((result));
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19351 PyObject *resultobj;
19352 int arg1 = (int) wxDateTime::Inv_Year ;
19353 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19354 bool result;
19355 PyObject * obj0 = 0 ;
19356 PyObject * obj1 = 0 ;
19357 char *kwnames[] = {
19358 (char *) "year",(char *) "cal", NULL
19359 };
19360
19361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19362 if (obj0) {
19363 {
19364 arg1 = (int)(SWIG_As_int(obj0));
19365 if (SWIG_arg_fail(1)) SWIG_fail;
19366 }
19367 }
19368 if (obj1) {
19369 {
19370 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19371 if (SWIG_arg_fail(2)) SWIG_fail;
19372 }
19373 }
19374 {
19375 PyThreadState* __tstate = wxPyBeginAllowThreads();
19376 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19377
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 {
19382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19383 }
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19391 PyObject *resultobj;
19392 int arg1 = (int) wxDateTime::Inv_Year ;
19393 int result;
19394 PyObject * obj0 = 0 ;
19395 char *kwnames[] = {
19396 (char *) "year", NULL
19397 };
19398
19399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19400 if (obj0) {
19401 {
19402 arg1 = (int)(SWIG_As_int(obj0));
19403 if (SWIG_arg_fail(1)) SWIG_fail;
19404 }
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (int)wxDateTime::GetCentury(arg1);
19409
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 {
19414 resultobj = SWIG_From_int((int)(result));
19415 }
19416 return resultobj;
19417 fail:
19418 return NULL;
19419 }
19420
19421
19422 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19423 PyObject *resultobj;
19424 int arg1 ;
19425 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19426 int result;
19427 PyObject * obj0 = 0 ;
19428 PyObject * obj1 = 0 ;
19429 char *kwnames[] = {
19430 (char *) "year",(char *) "cal", NULL
19431 };
19432
19433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19434 {
19435 arg1 = (int)(SWIG_As_int(obj0));
19436 if (SWIG_arg_fail(1)) SWIG_fail;
19437 }
19438 if (obj1) {
19439 {
19440 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19441 if (SWIG_arg_fail(2)) SWIG_fail;
19442 }
19443 }
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19447
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 {
19452 resultobj = SWIG_From_int((int)(result));
19453 }
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj;
19462 wxDateTime::Month arg1 ;
19463 int arg2 = (int) wxDateTime::Inv_Year ;
19464 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19465 int result;
19466 PyObject * obj0 = 0 ;
19467 PyObject * obj1 = 0 ;
19468 PyObject * obj2 = 0 ;
19469 char *kwnames[] = {
19470 (char *) "month",(char *) "year",(char *) "cal", NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19474 {
19475 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 }
19478 if (obj1) {
19479 {
19480 arg2 = (int)(SWIG_As_int(obj1));
19481 if (SWIG_arg_fail(2)) SWIG_fail;
19482 }
19483 }
19484 if (obj2) {
19485 {
19486 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19487 if (SWIG_arg_fail(3)) SWIG_fail;
19488 }
19489 }
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19493
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 {
19498 resultobj = SWIG_From_int((int)(result));
19499 }
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19507 PyObject *resultobj;
19508 wxDateTime::Month arg1 ;
19509 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19510 wxString result;
19511 PyObject * obj0 = 0 ;
19512 PyObject * obj1 = 0 ;
19513 char *kwnames[] = {
19514 (char *) "month",(char *) "flags", NULL
19515 };
19516
19517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19518 {
19519 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19520 if (SWIG_arg_fail(1)) SWIG_fail;
19521 }
19522 if (obj1) {
19523 {
19524 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19525 if (SWIG_arg_fail(2)) SWIG_fail;
19526 }
19527 }
19528 {
19529 PyThreadState* __tstate = wxPyBeginAllowThreads();
19530 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19531
19532 wxPyEndAllowThreads(__tstate);
19533 if (PyErr_Occurred()) SWIG_fail;
19534 }
19535 {
19536 #if wxUSE_UNICODE
19537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19538 #else
19539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19540 #endif
19541 }
19542 return resultobj;
19543 fail:
19544 return NULL;
19545 }
19546
19547
19548 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19549 PyObject *resultobj;
19550 wxDateTime::WeekDay arg1 ;
19551 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19552 wxString result;
19553 PyObject * obj0 = 0 ;
19554 PyObject * obj1 = 0 ;
19555 char *kwnames[] = {
19556 (char *) "weekday",(char *) "flags", NULL
19557 };
19558
19559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19560 {
19561 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19562 if (SWIG_arg_fail(1)) SWIG_fail;
19563 }
19564 if (obj1) {
19565 {
19566 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19567 if (SWIG_arg_fail(2)) SWIG_fail;
19568 }
19569 }
19570 {
19571 PyThreadState* __tstate = wxPyBeginAllowThreads();
19572 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19573
19574 wxPyEndAllowThreads(__tstate);
19575 if (PyErr_Occurred()) SWIG_fail;
19576 }
19577 {
19578 #if wxUSE_UNICODE
19579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19580 #else
19581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19582 #endif
19583 }
19584 return resultobj;
19585 fail:
19586 return NULL;
19587 }
19588
19589
19590 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19591 PyObject *resultobj;
19592 PyObject *result;
19593 char *kwnames[] = {
19594 NULL
19595 };
19596
19597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = (PyObject *)DateTime_GetAmPmStrings();
19601
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 resultobj = result;
19606 return resultobj;
19607 fail:
19608 return NULL;
19609 }
19610
19611
19612 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19613 PyObject *resultobj;
19614 int arg1 = (int) wxDateTime::Inv_Year ;
19615 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19616 bool result;
19617 PyObject * obj0 = 0 ;
19618 PyObject * obj1 = 0 ;
19619 char *kwnames[] = {
19620 (char *) "year",(char *) "country", NULL
19621 };
19622
19623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19624 if (obj0) {
19625 {
19626 arg1 = (int)(SWIG_As_int(obj0));
19627 if (SWIG_arg_fail(1)) SWIG_fail;
19628 }
19629 }
19630 if (obj1) {
19631 {
19632 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19633 if (SWIG_arg_fail(2)) SWIG_fail;
19634 }
19635 }
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19639
19640 wxPyEndAllowThreads(__tstate);
19641 if (PyErr_Occurred()) SWIG_fail;
19642 }
19643 {
19644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19645 }
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19653 PyObject *resultobj;
19654 int arg1 = (int) wxDateTime::Inv_Year ;
19655 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19656 wxDateTime result;
19657 PyObject * obj0 = 0 ;
19658 PyObject * obj1 = 0 ;
19659 char *kwnames[] = {
19660 (char *) "year",(char *) "country", NULL
19661 };
19662
19663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19664 if (obj0) {
19665 {
19666 arg1 = (int)(SWIG_As_int(obj0));
19667 if (SWIG_arg_fail(1)) SWIG_fail;
19668 }
19669 }
19670 if (obj1) {
19671 {
19672 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19673 if (SWIG_arg_fail(2)) SWIG_fail;
19674 }
19675 }
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19679
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 {
19684 wxDateTime * resultptr;
19685 resultptr = new wxDateTime((wxDateTime &)(result));
19686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19687 }
19688 return resultobj;
19689 fail:
19690 return NULL;
19691 }
19692
19693
19694 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19695 PyObject *resultobj;
19696 int arg1 = (int) wxDateTime::Inv_Year ;
19697 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19698 wxDateTime result;
19699 PyObject * obj0 = 0 ;
19700 PyObject * obj1 = 0 ;
19701 char *kwnames[] = {
19702 (char *) "year",(char *) "country", NULL
19703 };
19704
19705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19706 if (obj0) {
19707 {
19708 arg1 = (int)(SWIG_As_int(obj0));
19709 if (SWIG_arg_fail(1)) SWIG_fail;
19710 }
19711 }
19712 if (obj1) {
19713 {
19714 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 }
19717 }
19718 {
19719 PyThreadState* __tstate = wxPyBeginAllowThreads();
19720 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19721
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 {
19726 wxDateTime * resultptr;
19727 resultptr = new wxDateTime((wxDateTime &)(result));
19728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19729 }
19730 return resultobj;
19731 fail:
19732 return NULL;
19733 }
19734
19735
19736 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj;
19738 wxDateTime result;
19739 char *kwnames[] = {
19740 NULL
19741 };
19742
19743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = wxDateTime::Now();
19747
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 {
19752 wxDateTime * resultptr;
19753 resultptr = new wxDateTime((wxDateTime &)(result));
19754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19755 }
19756 return resultobj;
19757 fail:
19758 return NULL;
19759 }
19760
19761
19762 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19763 PyObject *resultobj;
19764 wxDateTime result;
19765 char *kwnames[] = {
19766 NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19770 {
19771 PyThreadState* __tstate = wxPyBeginAllowThreads();
19772 result = wxDateTime::UNow();
19773
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 {
19778 wxDateTime * resultptr;
19779 resultptr = new wxDateTime((wxDateTime &)(result));
19780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19781 }
19782 return resultobj;
19783 fail:
19784 return NULL;
19785 }
19786
19787
19788 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19789 PyObject *resultobj;
19790 wxDateTime result;
19791 char *kwnames[] = {
19792 NULL
19793 };
19794
19795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 result = wxDateTime::Today();
19799
19800 wxPyEndAllowThreads(__tstate);
19801 if (PyErr_Occurred()) SWIG_fail;
19802 }
19803 {
19804 wxDateTime * resultptr;
19805 resultptr = new wxDateTime((wxDateTime &)(result));
19806 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19807 }
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj;
19816 wxDateTime *result;
19817 char *kwnames[] = {
19818 NULL
19819 };
19820
19821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19822 {
19823 PyThreadState* __tstate = wxPyBeginAllowThreads();
19824 result = (wxDateTime *)new wxDateTime();
19825
19826 wxPyEndAllowThreads(__tstate);
19827 if (PyErr_Occurred()) SWIG_fail;
19828 }
19829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19830 return resultobj;
19831 fail:
19832 return NULL;
19833 }
19834
19835
19836 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj;
19838 time_t arg1 ;
19839 wxDateTime *result;
19840 PyObject * obj0 = 0 ;
19841 char *kwnames[] = {
19842 (char *) "timet", NULL
19843 };
19844
19845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19846 {
19847 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19848 if (SWIG_arg_fail(1)) SWIG_fail;
19849 }
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 result = (wxDateTime *)new wxDateTime(arg1);
19853
19854 wxPyEndAllowThreads(__tstate);
19855 if (PyErr_Occurred()) SWIG_fail;
19856 }
19857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19858 return resultobj;
19859 fail:
19860 return NULL;
19861 }
19862
19863
19864 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19865 PyObject *resultobj;
19866 double arg1 ;
19867 wxDateTime *result;
19868 PyObject * obj0 = 0 ;
19869 char *kwnames[] = {
19870 (char *) "jdn", NULL
19871 };
19872
19873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19874 {
19875 arg1 = (double)(SWIG_As_double(obj0));
19876 if (SWIG_arg_fail(1)) SWIG_fail;
19877 }
19878 {
19879 PyThreadState* __tstate = wxPyBeginAllowThreads();
19880 result = (wxDateTime *)new wxDateTime(arg1);
19881
19882 wxPyEndAllowThreads(__tstate);
19883 if (PyErr_Occurred()) SWIG_fail;
19884 }
19885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19886 return resultobj;
19887 fail:
19888 return NULL;
19889 }
19890
19891
19892 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19893 PyObject *resultobj;
19894 int arg1 ;
19895 int arg2 = (int) 0 ;
19896 int arg3 = (int) 0 ;
19897 int arg4 = (int) 0 ;
19898 wxDateTime *result;
19899 PyObject * obj0 = 0 ;
19900 PyObject * obj1 = 0 ;
19901 PyObject * obj2 = 0 ;
19902 PyObject * obj3 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19908 {
19909 arg1 = (int)(SWIG_As_int(obj0));
19910 if (SWIG_arg_fail(1)) SWIG_fail;
19911 }
19912 if (obj1) {
19913 {
19914 arg2 = (int)(SWIG_As_int(obj1));
19915 if (SWIG_arg_fail(2)) SWIG_fail;
19916 }
19917 }
19918 if (obj2) {
19919 {
19920 arg3 = (int)(SWIG_As_int(obj2));
19921 if (SWIG_arg_fail(3)) SWIG_fail;
19922 }
19923 }
19924 if (obj3) {
19925 {
19926 arg4 = (int)(SWIG_As_int(obj3));
19927 if (SWIG_arg_fail(4)) SWIG_fail;
19928 }
19929 }
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19933
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19945 PyObject *resultobj;
19946 int arg1 ;
19947 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19948 int arg3 = (int) wxDateTime::Inv_Year ;
19949 int arg4 = (int) 0 ;
19950 int arg5 = (int) 0 ;
19951 int arg6 = (int) 0 ;
19952 int arg7 = (int) 0 ;
19953 wxDateTime *result;
19954 PyObject * obj0 = 0 ;
19955 PyObject * obj1 = 0 ;
19956 PyObject * obj2 = 0 ;
19957 PyObject * obj3 = 0 ;
19958 PyObject * obj4 = 0 ;
19959 PyObject * obj5 = 0 ;
19960 PyObject * obj6 = 0 ;
19961 char *kwnames[] = {
19962 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19963 };
19964
19965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19966 {
19967 arg1 = (int)(SWIG_As_int(obj0));
19968 if (SWIG_arg_fail(1)) SWIG_fail;
19969 }
19970 if (obj1) {
19971 {
19972 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19973 if (SWIG_arg_fail(2)) SWIG_fail;
19974 }
19975 }
19976 if (obj2) {
19977 {
19978 arg3 = (int)(SWIG_As_int(obj2));
19979 if (SWIG_arg_fail(3)) SWIG_fail;
19980 }
19981 }
19982 if (obj3) {
19983 {
19984 arg4 = (int)(SWIG_As_int(obj3));
19985 if (SWIG_arg_fail(4)) SWIG_fail;
19986 }
19987 }
19988 if (obj4) {
19989 {
19990 arg5 = (int)(SWIG_As_int(obj4));
19991 if (SWIG_arg_fail(5)) SWIG_fail;
19992 }
19993 }
19994 if (obj5) {
19995 {
19996 arg6 = (int)(SWIG_As_int(obj5));
19997 if (SWIG_arg_fail(6)) SWIG_fail;
19998 }
19999 }
20000 if (obj6) {
20001 {
20002 arg7 = (int)(SWIG_As_int(obj6));
20003 if (SWIG_arg_fail(7)) SWIG_fail;
20004 }
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
20009
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj;
20022 wxDateTime *arg1 = (wxDateTime *) 0 ;
20023 PyObject * obj0 = 0 ;
20024 char *kwnames[] = {
20025 (char *) "self", NULL
20026 };
20027
20028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20030 if (SWIG_arg_fail(1)) SWIG_fail;
20031 {
20032 PyThreadState* __tstate = wxPyBeginAllowThreads();
20033 delete arg1;
20034
20035 wxPyEndAllowThreads(__tstate);
20036 if (PyErr_Occurred()) SWIG_fail;
20037 }
20038 Py_INCREF(Py_None); resultobj = Py_None;
20039 return resultobj;
20040 fail:
20041 return NULL;
20042 }
20043
20044
20045 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20046 PyObject *resultobj;
20047 wxDateTime *arg1 = (wxDateTime *) 0 ;
20048 wxDateTime *result;
20049 PyObject * obj0 = 0 ;
20050 char *kwnames[] = {
20051 (char *) "self", NULL
20052 };
20053
20054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
20055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20056 if (SWIG_arg_fail(1)) SWIG_fail;
20057 {
20058 PyThreadState* __tstate = wxPyBeginAllowThreads();
20059 {
20060 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20061 result = (wxDateTime *) &_result_ref;
20062 }
20063
20064 wxPyEndAllowThreads(__tstate);
20065 if (PyErr_Occurred()) SWIG_fail;
20066 }
20067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj;
20076 wxDateTime *arg1 = (wxDateTime *) 0 ;
20077 time_t arg2 ;
20078 wxDateTime *result;
20079 PyObject * obj0 = 0 ;
20080 PyObject * obj1 = 0 ;
20081 char *kwnames[] = {
20082 (char *) "self",(char *) "timet", NULL
20083 };
20084
20085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20087 if (SWIG_arg_fail(1)) SWIG_fail;
20088 {
20089 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
20090 if (SWIG_arg_fail(2)) SWIG_fail;
20091 }
20092 {
20093 PyThreadState* __tstate = wxPyBeginAllowThreads();
20094 {
20095 wxDateTime &_result_ref = (arg1)->Set(arg2);
20096 result = (wxDateTime *) &_result_ref;
20097 }
20098
20099 wxPyEndAllowThreads(__tstate);
20100 if (PyErr_Occurred()) SWIG_fail;
20101 }
20102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj;
20111 wxDateTime *arg1 = (wxDateTime *) 0 ;
20112 double arg2 ;
20113 wxDateTime *result;
20114 PyObject * obj0 = 0 ;
20115 PyObject * obj1 = 0 ;
20116 char *kwnames[] = {
20117 (char *) "self",(char *) "jdn", NULL
20118 };
20119
20120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20122 if (SWIG_arg_fail(1)) SWIG_fail;
20123 {
20124 arg2 = (double)(SWIG_As_double(obj1));
20125 if (SWIG_arg_fail(2)) SWIG_fail;
20126 }
20127 {
20128 PyThreadState* __tstate = wxPyBeginAllowThreads();
20129 {
20130 wxDateTime &_result_ref = (arg1)->Set(arg2);
20131 result = (wxDateTime *) &_result_ref;
20132 }
20133
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20138 return resultobj;
20139 fail:
20140 return NULL;
20141 }
20142
20143
20144 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20145 PyObject *resultobj;
20146 wxDateTime *arg1 = (wxDateTime *) 0 ;
20147 int arg2 ;
20148 int arg3 = (int) 0 ;
20149 int arg4 = (int) 0 ;
20150 int arg5 = (int) 0 ;
20151 wxDateTime *result;
20152 PyObject * obj0 = 0 ;
20153 PyObject * obj1 = 0 ;
20154 PyObject * obj2 = 0 ;
20155 PyObject * obj3 = 0 ;
20156 PyObject * obj4 = 0 ;
20157 char *kwnames[] = {
20158 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20159 };
20160
20161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20163 if (SWIG_arg_fail(1)) SWIG_fail;
20164 {
20165 arg2 = (int)(SWIG_As_int(obj1));
20166 if (SWIG_arg_fail(2)) SWIG_fail;
20167 }
20168 if (obj2) {
20169 {
20170 arg3 = (int)(SWIG_As_int(obj2));
20171 if (SWIG_arg_fail(3)) SWIG_fail;
20172 }
20173 }
20174 if (obj3) {
20175 {
20176 arg4 = (int)(SWIG_As_int(obj3));
20177 if (SWIG_arg_fail(4)) SWIG_fail;
20178 }
20179 }
20180 if (obj4) {
20181 {
20182 arg5 = (int)(SWIG_As_int(obj4));
20183 if (SWIG_arg_fail(5)) SWIG_fail;
20184 }
20185 }
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 {
20189 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20190 result = (wxDateTime *) &_result_ref;
20191 }
20192
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj;
20205 wxDateTime *arg1 = (wxDateTime *) 0 ;
20206 int arg2 ;
20207 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20208 int arg4 = (int) wxDateTime::Inv_Year ;
20209 int arg5 = (int) 0 ;
20210 int arg6 = (int) 0 ;
20211 int arg7 = (int) 0 ;
20212 int arg8 = (int) 0 ;
20213 wxDateTime *result;
20214 PyObject * obj0 = 0 ;
20215 PyObject * obj1 = 0 ;
20216 PyObject * obj2 = 0 ;
20217 PyObject * obj3 = 0 ;
20218 PyObject * obj4 = 0 ;
20219 PyObject * obj5 = 0 ;
20220 PyObject * obj6 = 0 ;
20221 PyObject * obj7 = 0 ;
20222 char *kwnames[] = {
20223 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20224 };
20225
20226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20228 if (SWIG_arg_fail(1)) SWIG_fail;
20229 {
20230 arg2 = (int)(SWIG_As_int(obj1));
20231 if (SWIG_arg_fail(2)) SWIG_fail;
20232 }
20233 if (obj2) {
20234 {
20235 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20236 if (SWIG_arg_fail(3)) SWIG_fail;
20237 }
20238 }
20239 if (obj3) {
20240 {
20241 arg4 = (int)(SWIG_As_int(obj3));
20242 if (SWIG_arg_fail(4)) SWIG_fail;
20243 }
20244 }
20245 if (obj4) {
20246 {
20247 arg5 = (int)(SWIG_As_int(obj4));
20248 if (SWIG_arg_fail(5)) SWIG_fail;
20249 }
20250 }
20251 if (obj5) {
20252 {
20253 arg6 = (int)(SWIG_As_int(obj5));
20254 if (SWIG_arg_fail(6)) SWIG_fail;
20255 }
20256 }
20257 if (obj6) {
20258 {
20259 arg7 = (int)(SWIG_As_int(obj6));
20260 if (SWIG_arg_fail(7)) SWIG_fail;
20261 }
20262 }
20263 if (obj7) {
20264 {
20265 arg8 = (int)(SWIG_As_int(obj7));
20266 if (SWIG_arg_fail(8)) SWIG_fail;
20267 }
20268 }
20269 {
20270 PyThreadState* __tstate = wxPyBeginAllowThreads();
20271 {
20272 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20273 result = (wxDateTime *) &_result_ref;
20274 }
20275
20276 wxPyEndAllowThreads(__tstate);
20277 if (PyErr_Occurred()) SWIG_fail;
20278 }
20279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20280 return resultobj;
20281 fail:
20282 return NULL;
20283 }
20284
20285
20286 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20287 PyObject *resultobj;
20288 wxDateTime *arg1 = (wxDateTime *) 0 ;
20289 wxDateTime *result;
20290 PyObject * obj0 = 0 ;
20291 char *kwnames[] = {
20292 (char *) "self", NULL
20293 };
20294
20295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20297 if (SWIG_arg_fail(1)) SWIG_fail;
20298 {
20299 PyThreadState* __tstate = wxPyBeginAllowThreads();
20300 {
20301 wxDateTime &_result_ref = (arg1)->ResetTime();
20302 result = (wxDateTime *) &_result_ref;
20303 }
20304
20305 wxPyEndAllowThreads(__tstate);
20306 if (PyErr_Occurred()) SWIG_fail;
20307 }
20308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20309 return resultobj;
20310 fail:
20311 return NULL;
20312 }
20313
20314
20315 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20316 PyObject *resultobj;
20317 wxDateTime *arg1 = (wxDateTime *) 0 ;
20318 int arg2 ;
20319 wxDateTime *result;
20320 PyObject * obj0 = 0 ;
20321 PyObject * obj1 = 0 ;
20322 char *kwnames[] = {
20323 (char *) "self",(char *) "year", NULL
20324 };
20325
20326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20328 if (SWIG_arg_fail(1)) SWIG_fail;
20329 {
20330 arg2 = (int)(SWIG_As_int(obj1));
20331 if (SWIG_arg_fail(2)) SWIG_fail;
20332 }
20333 {
20334 PyThreadState* __tstate = wxPyBeginAllowThreads();
20335 {
20336 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20337 result = (wxDateTime *) &_result_ref;
20338 }
20339
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20351 PyObject *resultobj;
20352 wxDateTime *arg1 = (wxDateTime *) 0 ;
20353 wxDateTime::Month arg2 ;
20354 wxDateTime *result;
20355 PyObject * obj0 = 0 ;
20356 PyObject * obj1 = 0 ;
20357 char *kwnames[] = {
20358 (char *) "self",(char *) "month", NULL
20359 };
20360
20361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20363 if (SWIG_arg_fail(1)) SWIG_fail;
20364 {
20365 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20366 if (SWIG_arg_fail(2)) SWIG_fail;
20367 }
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 {
20371 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20372 result = (wxDateTime *) &_result_ref;
20373 }
20374
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20386 PyObject *resultobj;
20387 wxDateTime *arg1 = (wxDateTime *) 0 ;
20388 int arg2 ;
20389 wxDateTime *result;
20390 PyObject * obj0 = 0 ;
20391 PyObject * obj1 = 0 ;
20392 char *kwnames[] = {
20393 (char *) "self",(char *) "day", NULL
20394 };
20395
20396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20398 if (SWIG_arg_fail(1)) SWIG_fail;
20399 {
20400 arg2 = (int)(SWIG_As_int(obj1));
20401 if (SWIG_arg_fail(2)) SWIG_fail;
20402 }
20403 {
20404 PyThreadState* __tstate = wxPyBeginAllowThreads();
20405 {
20406 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20407 result = (wxDateTime *) &_result_ref;
20408 }
20409
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20414 return resultobj;
20415 fail:
20416 return NULL;
20417 }
20418
20419
20420 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20421 PyObject *resultobj;
20422 wxDateTime *arg1 = (wxDateTime *) 0 ;
20423 int arg2 ;
20424 wxDateTime *result;
20425 PyObject * obj0 = 0 ;
20426 PyObject * obj1 = 0 ;
20427 char *kwnames[] = {
20428 (char *) "self",(char *) "hour", NULL
20429 };
20430
20431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20433 if (SWIG_arg_fail(1)) SWIG_fail;
20434 {
20435 arg2 = (int)(SWIG_As_int(obj1));
20436 if (SWIG_arg_fail(2)) SWIG_fail;
20437 }
20438 {
20439 PyThreadState* __tstate = wxPyBeginAllowThreads();
20440 {
20441 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20442 result = (wxDateTime *) &_result_ref;
20443 }
20444
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj;
20457 wxDateTime *arg1 = (wxDateTime *) 0 ;
20458 int arg2 ;
20459 wxDateTime *result;
20460 PyObject * obj0 = 0 ;
20461 PyObject * obj1 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "self",(char *) "minute", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 {
20470 arg2 = (int)(SWIG_As_int(obj1));
20471 if (SWIG_arg_fail(2)) SWIG_fail;
20472 }
20473 {
20474 PyThreadState* __tstate = wxPyBeginAllowThreads();
20475 {
20476 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20477 result = (wxDateTime *) &_result_ref;
20478 }
20479
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj;
20492 wxDateTime *arg1 = (wxDateTime *) 0 ;
20493 int arg2 ;
20494 wxDateTime *result;
20495 PyObject * obj0 = 0 ;
20496 PyObject * obj1 = 0 ;
20497 char *kwnames[] = {
20498 (char *) "self",(char *) "second", NULL
20499 };
20500
20501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20503 if (SWIG_arg_fail(1)) SWIG_fail;
20504 {
20505 arg2 = (int)(SWIG_As_int(obj1));
20506 if (SWIG_arg_fail(2)) SWIG_fail;
20507 }
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 {
20511 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20512 result = (wxDateTime *) &_result_ref;
20513 }
20514
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 wxDateTime *arg1 = (wxDateTime *) 0 ;
20528 int arg2 ;
20529 wxDateTime *result;
20530 PyObject * obj0 = 0 ;
20531 PyObject * obj1 = 0 ;
20532 char *kwnames[] = {
20533 (char *) "self",(char *) "millisecond", NULL
20534 };
20535
20536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20538 if (SWIG_arg_fail(1)) SWIG_fail;
20539 {
20540 arg2 = (int)(SWIG_As_int(obj1));
20541 if (SWIG_arg_fail(2)) SWIG_fail;
20542 }
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 {
20546 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20547 result = (wxDateTime *) &_result_ref;
20548 }
20549
20550 wxPyEndAllowThreads(__tstate);
20551 if (PyErr_Occurred()) SWIG_fail;
20552 }
20553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20561 PyObject *resultobj;
20562 wxDateTime *arg1 = (wxDateTime *) 0 ;
20563 wxDateTime::WeekDay arg2 ;
20564 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20565 wxDateTime *result;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 PyObject * obj2 = 0 ;
20569 char *kwnames[] = {
20570 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20571 };
20572
20573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20575 if (SWIG_arg_fail(1)) SWIG_fail;
20576 {
20577 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20578 if (SWIG_arg_fail(2)) SWIG_fail;
20579 }
20580 if (obj2) {
20581 {
20582 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20583 if (SWIG_arg_fail(3)) SWIG_fail;
20584 }
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 {
20589 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20590 result = (wxDateTime *) &_result_ref;
20591 }
20592
20593 wxPyEndAllowThreads(__tstate);
20594 if (PyErr_Occurred()) SWIG_fail;
20595 }
20596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20604 PyObject *resultobj;
20605 wxDateTime *arg1 = (wxDateTime *) 0 ;
20606 wxDateTime::WeekDay arg2 ;
20607 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20608 wxDateTime result;
20609 PyObject * obj0 = 0 ;
20610 PyObject * obj1 = 0 ;
20611 PyObject * obj2 = 0 ;
20612 char *kwnames[] = {
20613 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20614 };
20615
20616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20618 if (SWIG_arg_fail(1)) SWIG_fail;
20619 {
20620 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20621 if (SWIG_arg_fail(2)) SWIG_fail;
20622 }
20623 if (obj2) {
20624 {
20625 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20626 if (SWIG_arg_fail(3)) SWIG_fail;
20627 }
20628 }
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20632
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 {
20637 wxDateTime * resultptr;
20638 resultptr = new wxDateTime((wxDateTime &)(result));
20639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20640 }
20641 return resultobj;
20642 fail:
20643 return NULL;
20644 }
20645
20646
20647 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20648 PyObject *resultobj;
20649 wxDateTime *arg1 = (wxDateTime *) 0 ;
20650 wxDateTime::WeekDay arg2 ;
20651 wxDateTime *result;
20652 PyObject * obj0 = 0 ;
20653 PyObject * obj1 = 0 ;
20654 char *kwnames[] = {
20655 (char *) "self",(char *) "weekday", NULL
20656 };
20657
20658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20660 if (SWIG_arg_fail(1)) SWIG_fail;
20661 {
20662 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20663 if (SWIG_arg_fail(2)) SWIG_fail;
20664 }
20665 {
20666 PyThreadState* __tstate = wxPyBeginAllowThreads();
20667 {
20668 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20669 result = (wxDateTime *) &_result_ref;
20670 }
20671
20672 wxPyEndAllowThreads(__tstate);
20673 if (PyErr_Occurred()) SWIG_fail;
20674 }
20675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20676 return resultobj;
20677 fail:
20678 return NULL;
20679 }
20680
20681
20682 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20683 PyObject *resultobj;
20684 wxDateTime *arg1 = (wxDateTime *) 0 ;
20685 wxDateTime::WeekDay arg2 ;
20686 wxDateTime result;
20687 PyObject * obj0 = 0 ;
20688 PyObject * obj1 = 0 ;
20689 char *kwnames[] = {
20690 (char *) "self",(char *) "weekday", NULL
20691 };
20692
20693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20695 if (SWIG_arg_fail(1)) SWIG_fail;
20696 {
20697 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20698 if (SWIG_arg_fail(2)) SWIG_fail;
20699 }
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20703
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 {
20708 wxDateTime * resultptr;
20709 resultptr = new wxDateTime((wxDateTime &)(result));
20710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20711 }
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20719 PyObject *resultobj;
20720 wxDateTime *arg1 = (wxDateTime *) 0 ;
20721 wxDateTime::WeekDay arg2 ;
20722 wxDateTime *result;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 char *kwnames[] = {
20726 (char *) "self",(char *) "weekday", NULL
20727 };
20728
20729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20731 if (SWIG_arg_fail(1)) SWIG_fail;
20732 {
20733 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20734 if (SWIG_arg_fail(2)) SWIG_fail;
20735 }
20736 {
20737 PyThreadState* __tstate = wxPyBeginAllowThreads();
20738 {
20739 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20740 result = (wxDateTime *) &_result_ref;
20741 }
20742
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20754 PyObject *resultobj;
20755 wxDateTime *arg1 = (wxDateTime *) 0 ;
20756 wxDateTime::WeekDay arg2 ;
20757 wxDateTime result;
20758 PyObject * obj0 = 0 ;
20759 PyObject * obj1 = 0 ;
20760 char *kwnames[] = {
20761 (char *) "self",(char *) "weekday", NULL
20762 };
20763
20764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20766 if (SWIG_arg_fail(1)) SWIG_fail;
20767 {
20768 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20769 if (SWIG_arg_fail(2)) SWIG_fail;
20770 }
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20774
20775 wxPyEndAllowThreads(__tstate);
20776 if (PyErr_Occurred()) SWIG_fail;
20777 }
20778 {
20779 wxDateTime * resultptr;
20780 resultptr = new wxDateTime((wxDateTime &)(result));
20781 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20782 }
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20790 PyObject *resultobj;
20791 wxDateTime *arg1 = (wxDateTime *) 0 ;
20792 wxDateTime::WeekDay arg2 ;
20793 int arg3 = (int) 1 ;
20794 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20795 int arg5 = (int) wxDateTime::Inv_Year ;
20796 bool result;
20797 PyObject * obj0 = 0 ;
20798 PyObject * obj1 = 0 ;
20799 PyObject * obj2 = 0 ;
20800 PyObject * obj3 = 0 ;
20801 PyObject * obj4 = 0 ;
20802 char *kwnames[] = {
20803 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20804 };
20805
20806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20808 if (SWIG_arg_fail(1)) SWIG_fail;
20809 {
20810 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20811 if (SWIG_arg_fail(2)) SWIG_fail;
20812 }
20813 if (obj2) {
20814 {
20815 arg3 = (int)(SWIG_As_int(obj2));
20816 if (SWIG_arg_fail(3)) SWIG_fail;
20817 }
20818 }
20819 if (obj3) {
20820 {
20821 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20822 if (SWIG_arg_fail(4)) SWIG_fail;
20823 }
20824 }
20825 if (obj4) {
20826 {
20827 arg5 = (int)(SWIG_As_int(obj4));
20828 if (SWIG_arg_fail(5)) SWIG_fail;
20829 }
20830 }
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20834
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 {
20839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20840 }
20841 return resultobj;
20842 fail:
20843 return NULL;
20844 }
20845
20846
20847 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20848 PyObject *resultobj;
20849 wxDateTime *arg1 = (wxDateTime *) 0 ;
20850 wxDateTime::WeekDay arg2 ;
20851 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20852 int arg4 = (int) wxDateTime::Inv_Year ;
20853 bool result;
20854 PyObject * obj0 = 0 ;
20855 PyObject * obj1 = 0 ;
20856 PyObject * obj2 = 0 ;
20857 PyObject * obj3 = 0 ;
20858 char *kwnames[] = {
20859 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20860 };
20861
20862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20864 if (SWIG_arg_fail(1)) SWIG_fail;
20865 {
20866 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20867 if (SWIG_arg_fail(2)) SWIG_fail;
20868 }
20869 if (obj2) {
20870 {
20871 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20872 if (SWIG_arg_fail(3)) SWIG_fail;
20873 }
20874 }
20875 if (obj3) {
20876 {
20877 arg4 = (int)(SWIG_As_int(obj3));
20878 if (SWIG_arg_fail(4)) SWIG_fail;
20879 }
20880 }
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20884
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 {
20889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20890 }
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 wxDateTime *arg1 = (wxDateTime *) 0 ;
20900 wxDateTime::WeekDay arg2 ;
20901 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20902 int arg4 = (int) wxDateTime::Inv_Year ;
20903 wxDateTime result;
20904 PyObject * obj0 = 0 ;
20905 PyObject * obj1 = 0 ;
20906 PyObject * obj2 = 0 ;
20907 PyObject * obj3 = 0 ;
20908 char *kwnames[] = {
20909 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20910 };
20911
20912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20914 if (SWIG_arg_fail(1)) SWIG_fail;
20915 {
20916 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20917 if (SWIG_arg_fail(2)) SWIG_fail;
20918 }
20919 if (obj2) {
20920 {
20921 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20922 if (SWIG_arg_fail(3)) SWIG_fail;
20923 }
20924 }
20925 if (obj3) {
20926 {
20927 arg4 = (int)(SWIG_As_int(obj3));
20928 if (SWIG_arg_fail(4)) SWIG_fail;
20929 }
20930 }
20931 {
20932 PyThreadState* __tstate = wxPyBeginAllowThreads();
20933 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20934
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 {
20939 wxDateTime * resultptr;
20940 resultptr = new wxDateTime((wxDateTime &)(result));
20941 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20942 }
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20950 PyObject *resultobj;
20951 wxDateTime *arg1 = (wxDateTime *) 0 ;
20952 int arg2 ;
20953 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20954 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20955 bool result;
20956 PyObject * obj0 = 0 ;
20957 PyObject * obj1 = 0 ;
20958 PyObject * obj2 = 0 ;
20959 PyObject * obj3 = 0 ;
20960 char *kwnames[] = {
20961 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20962 };
20963
20964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(1)) SWIG_fail;
20967 {
20968 arg2 = (int)(SWIG_As_int(obj1));
20969 if (SWIG_arg_fail(2)) SWIG_fail;
20970 }
20971 if (obj2) {
20972 {
20973 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20974 if (SWIG_arg_fail(3)) SWIG_fail;
20975 }
20976 }
20977 if (obj3) {
20978 {
20979 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20980 if (SWIG_arg_fail(4)) SWIG_fail;
20981 }
20982 }
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20986
20987 wxPyEndAllowThreads(__tstate);
20988 if (PyErr_Occurred()) SWIG_fail;
20989 }
20990 {
20991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20992 }
20993 return resultobj;
20994 fail:
20995 return NULL;
20996 }
20997
20998
20999 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21000 PyObject *resultobj;
21001 wxDateTime *arg1 = (wxDateTime *) 0 ;
21002 int arg2 ;
21003 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21004 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21005 wxDateTime result;
21006 PyObject * obj0 = 0 ;
21007 PyObject * obj1 = 0 ;
21008 PyObject * obj2 = 0 ;
21009 PyObject * obj3 = 0 ;
21010 char *kwnames[] = {
21011 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21012 };
21013
21014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21016 if (SWIG_arg_fail(1)) SWIG_fail;
21017 {
21018 arg2 = (int)(SWIG_As_int(obj1));
21019 if (SWIG_arg_fail(2)) SWIG_fail;
21020 }
21021 if (obj2) {
21022 {
21023 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
21024 if (SWIG_arg_fail(3)) SWIG_fail;
21025 }
21026 }
21027 if (obj3) {
21028 {
21029 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
21030 if (SWIG_arg_fail(4)) SWIG_fail;
21031 }
21032 }
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
21036
21037 wxPyEndAllowThreads(__tstate);
21038 if (PyErr_Occurred()) SWIG_fail;
21039 }
21040 {
21041 wxDateTime * resultptr;
21042 resultptr = new wxDateTime((wxDateTime &)(result));
21043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21044 }
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21052 PyObject *resultobj;
21053 int arg1 ;
21054 int arg2 ;
21055 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21056 wxDateTime result;
21057 PyObject * obj0 = 0 ;
21058 PyObject * obj1 = 0 ;
21059 PyObject * obj2 = 0 ;
21060 char *kwnames[] = {
21061 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21062 };
21063
21064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21065 {
21066 arg1 = (int)(SWIG_As_int(obj0));
21067 if (SWIG_arg_fail(1)) SWIG_fail;
21068 }
21069 {
21070 arg2 = (int)(SWIG_As_int(obj1));
21071 if (SWIG_arg_fail(2)) SWIG_fail;
21072 }
21073 if (obj2) {
21074 {
21075 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
21076 if (SWIG_arg_fail(3)) SWIG_fail;
21077 }
21078 }
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 {
21087 wxDateTime * resultptr;
21088 resultptr = new wxDateTime((wxDateTime &)(result));
21089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21090 }
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21098 PyObject *resultobj;
21099 wxDateTime *arg1 = (wxDateTime *) 0 ;
21100 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21101 int arg3 = (int) wxDateTime::Inv_Year ;
21102 wxDateTime *result;
21103 PyObject * obj0 = 0 ;
21104 PyObject * obj1 = 0 ;
21105 PyObject * obj2 = 0 ;
21106 char *kwnames[] = {
21107 (char *) "self",(char *) "month",(char *) "year", NULL
21108 };
21109
21110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 if (obj1) {
21114 {
21115 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21116 if (SWIG_arg_fail(2)) SWIG_fail;
21117 }
21118 }
21119 if (obj2) {
21120 {
21121 arg3 = (int)(SWIG_As_int(obj2));
21122 if (SWIG_arg_fail(3)) SWIG_fail;
21123 }
21124 }
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 {
21128 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
21129 result = (wxDateTime *) &_result_ref;
21130 }
21131
21132 wxPyEndAllowThreads(__tstate);
21133 if (PyErr_Occurred()) SWIG_fail;
21134 }
21135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxDateTime *arg1 = (wxDateTime *) 0 ;
21145 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21146 int arg3 = (int) wxDateTime::Inv_Year ;
21147 wxDateTime result;
21148 PyObject * obj0 = 0 ;
21149 PyObject * obj1 = 0 ;
21150 PyObject * obj2 = 0 ;
21151 char *kwnames[] = {
21152 (char *) "self",(char *) "month",(char *) "year", NULL
21153 };
21154
21155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21157 if (SWIG_arg_fail(1)) SWIG_fail;
21158 if (obj1) {
21159 {
21160 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21161 if (SWIG_arg_fail(2)) SWIG_fail;
21162 }
21163 }
21164 if (obj2) {
21165 {
21166 arg3 = (int)(SWIG_As_int(obj2));
21167 if (SWIG_arg_fail(3)) SWIG_fail;
21168 }
21169 }
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 {
21178 wxDateTime * resultptr;
21179 resultptr = new wxDateTime((wxDateTime &)(result));
21180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21181 }
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxDateTime *arg1 = (wxDateTime *) 0 ;
21191 int arg2 ;
21192 wxDateTime *result;
21193 PyObject * obj0 = 0 ;
21194 PyObject * obj1 = 0 ;
21195 char *kwnames[] = {
21196 (char *) "self",(char *) "yday", NULL
21197 };
21198
21199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 {
21203 arg2 = (int)(SWIG_As_int(obj1));
21204 if (SWIG_arg_fail(2)) SWIG_fail;
21205 }
21206 {
21207 PyThreadState* __tstate = wxPyBeginAllowThreads();
21208 {
21209 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21210 result = (wxDateTime *) &_result_ref;
21211 }
21212
21213 wxPyEndAllowThreads(__tstate);
21214 if (PyErr_Occurred()) SWIG_fail;
21215 }
21216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21224 PyObject *resultobj;
21225 wxDateTime *arg1 = (wxDateTime *) 0 ;
21226 int arg2 ;
21227 wxDateTime result;
21228 PyObject * obj0 = 0 ;
21229 PyObject * obj1 = 0 ;
21230 char *kwnames[] = {
21231 (char *) "self",(char *) "yday", NULL
21232 };
21233
21234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(1)) SWIG_fail;
21237 {
21238 arg2 = (int)(SWIG_As_int(obj1));
21239 if (SWIG_arg_fail(2)) SWIG_fail;
21240 }
21241 {
21242 PyThreadState* __tstate = wxPyBeginAllowThreads();
21243 result = (arg1)->GetYearDay(arg2);
21244
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 {
21249 wxDateTime * resultptr;
21250 resultptr = new wxDateTime((wxDateTime &)(result));
21251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21252 }
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21260 PyObject *resultobj;
21261 wxDateTime *arg1 = (wxDateTime *) 0 ;
21262 double result;
21263 PyObject * obj0 = 0 ;
21264 char *kwnames[] = {
21265 (char *) "self", NULL
21266 };
21267
21268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21270 if (SWIG_arg_fail(1)) SWIG_fail;
21271 {
21272 PyThreadState* __tstate = wxPyBeginAllowThreads();
21273 result = (double)(arg1)->GetJulianDayNumber();
21274
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 {
21279 resultobj = SWIG_From_double((double)(result));
21280 }
21281 return resultobj;
21282 fail:
21283 return NULL;
21284 }
21285
21286
21287 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21288 PyObject *resultobj;
21289 wxDateTime *arg1 = (wxDateTime *) 0 ;
21290 double result;
21291 PyObject * obj0 = 0 ;
21292 char *kwnames[] = {
21293 (char *) "self", NULL
21294 };
21295
21296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21298 if (SWIG_arg_fail(1)) SWIG_fail;
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (double)(arg1)->GetJDN();
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 {
21307 resultobj = SWIG_From_double((double)(result));
21308 }
21309 return resultobj;
21310 fail:
21311 return NULL;
21312 }
21313
21314
21315 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21316 PyObject *resultobj;
21317 wxDateTime *arg1 = (wxDateTime *) 0 ;
21318 double result;
21319 PyObject * obj0 = 0 ;
21320 char *kwnames[] = {
21321 (char *) "self", NULL
21322 };
21323
21324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21326 if (SWIG_arg_fail(1)) SWIG_fail;
21327 {
21328 PyThreadState* __tstate = wxPyBeginAllowThreads();
21329 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21330
21331 wxPyEndAllowThreads(__tstate);
21332 if (PyErr_Occurred()) SWIG_fail;
21333 }
21334 {
21335 resultobj = SWIG_From_double((double)(result));
21336 }
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21344 PyObject *resultobj;
21345 wxDateTime *arg1 = (wxDateTime *) 0 ;
21346 double result;
21347 PyObject * obj0 = 0 ;
21348 char *kwnames[] = {
21349 (char *) "self", NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21354 if (SWIG_arg_fail(1)) SWIG_fail;
21355 {
21356 PyThreadState* __tstate = wxPyBeginAllowThreads();
21357 result = (double)(arg1)->GetMJD();
21358
21359 wxPyEndAllowThreads(__tstate);
21360 if (PyErr_Occurred()) SWIG_fail;
21361 }
21362 {
21363 resultobj = SWIG_From_double((double)(result));
21364 }
21365 return resultobj;
21366 fail:
21367 return NULL;
21368 }
21369
21370
21371 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21372 PyObject *resultobj;
21373 wxDateTime *arg1 = (wxDateTime *) 0 ;
21374 double result;
21375 PyObject * obj0 = 0 ;
21376 char *kwnames[] = {
21377 (char *) "self", NULL
21378 };
21379
21380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21382 if (SWIG_arg_fail(1)) SWIG_fail;
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 result = (double)(arg1)->GetRataDie();
21386
21387 wxPyEndAllowThreads(__tstate);
21388 if (PyErr_Occurred()) SWIG_fail;
21389 }
21390 {
21391 resultobj = SWIG_From_double((double)(result));
21392 }
21393 return resultobj;
21394 fail:
21395 return NULL;
21396 }
21397
21398
21399 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21400 PyObject *resultobj;
21401 wxDateTime *arg1 = (wxDateTime *) 0 ;
21402 wxDateTime::TimeZone *arg2 = 0 ;
21403 bool arg3 = (bool) false ;
21404 wxDateTime result;
21405 bool temp2 = false ;
21406 PyObject * obj0 = 0 ;
21407 PyObject * obj1 = 0 ;
21408 PyObject * obj2 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) 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 {
21417 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21418 temp2 = true;
21419 }
21420 if (obj2) {
21421 {
21422 arg3 = (bool)(SWIG_As_bool(obj2));
21423 if (SWIG_arg_fail(3)) SWIG_fail;
21424 }
21425 }
21426 {
21427 PyThreadState* __tstate = wxPyBeginAllowThreads();
21428 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21429
21430 wxPyEndAllowThreads(__tstate);
21431 if (PyErr_Occurred()) SWIG_fail;
21432 }
21433 {
21434 wxDateTime * resultptr;
21435 resultptr = new wxDateTime((wxDateTime &)(result));
21436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21437 }
21438 {
21439 if (temp2) delete arg2;
21440 }
21441 return resultobj;
21442 fail:
21443 {
21444 if (temp2) delete arg2;
21445 }
21446 return NULL;
21447 }
21448
21449
21450 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21451 PyObject *resultobj;
21452 wxDateTime *arg1 = (wxDateTime *) 0 ;
21453 wxDateTime::TimeZone *arg2 = 0 ;
21454 bool arg3 = (bool) false ;
21455 wxDateTime *result;
21456 bool temp2 = false ;
21457 PyObject * obj0 = 0 ;
21458 PyObject * obj1 = 0 ;
21459 PyObject * obj2 = 0 ;
21460 char *kwnames[] = {
21461 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21462 };
21463
21464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21466 if (SWIG_arg_fail(1)) SWIG_fail;
21467 {
21468 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21469 temp2 = true;
21470 }
21471 if (obj2) {
21472 {
21473 arg3 = (bool)(SWIG_As_bool(obj2));
21474 if (SWIG_arg_fail(3)) SWIG_fail;
21475 }
21476 }
21477 {
21478 PyThreadState* __tstate = wxPyBeginAllowThreads();
21479 {
21480 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21481 result = (wxDateTime *) &_result_ref;
21482 }
21483
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21488 {
21489 if (temp2) delete arg2;
21490 }
21491 return resultobj;
21492 fail:
21493 {
21494 if (temp2) delete arg2;
21495 }
21496 return NULL;
21497 }
21498
21499
21500 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21501 PyObject *resultobj;
21502 wxDateTime *arg1 = (wxDateTime *) 0 ;
21503 bool arg2 = (bool) false ;
21504 wxDateTime result;
21505 PyObject * obj0 = 0 ;
21506 PyObject * obj1 = 0 ;
21507 char *kwnames[] = {
21508 (char *) "self",(char *) "noDST", NULL
21509 };
21510
21511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) 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 = (bool)(SWIG_As_bool(obj1));
21517 if (SWIG_arg_fail(2)) SWIG_fail;
21518 }
21519 }
21520 {
21521 PyThreadState* __tstate = wxPyBeginAllowThreads();
21522 result = (arg1)->ToGMT(arg2);
21523
21524 wxPyEndAllowThreads(__tstate);
21525 if (PyErr_Occurred()) SWIG_fail;
21526 }
21527 {
21528 wxDateTime * resultptr;
21529 resultptr = new wxDateTime((wxDateTime &)(result));
21530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21531 }
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21539 PyObject *resultobj;
21540 wxDateTime *arg1 = (wxDateTime *) 0 ;
21541 bool arg2 = (bool) false ;
21542 wxDateTime *result;
21543 PyObject * obj0 = 0 ;
21544 PyObject * obj1 = 0 ;
21545 char *kwnames[] = {
21546 (char *) "self",(char *) "noDST", NULL
21547 };
21548
21549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21551 if (SWIG_arg_fail(1)) SWIG_fail;
21552 if (obj1) {
21553 {
21554 arg2 = (bool)(SWIG_As_bool(obj1));
21555 if (SWIG_arg_fail(2)) SWIG_fail;
21556 }
21557 }
21558 {
21559 PyThreadState* __tstate = wxPyBeginAllowThreads();
21560 {
21561 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21562 result = (wxDateTime *) &_result_ref;
21563 }
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21576 PyObject *resultobj;
21577 wxDateTime *arg1 = (wxDateTime *) 0 ;
21578 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21579 int result;
21580 PyObject * obj0 = 0 ;
21581 PyObject * obj1 = 0 ;
21582 char *kwnames[] = {
21583 (char *) "self",(char *) "country", NULL
21584 };
21585
21586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21588 if (SWIG_arg_fail(1)) SWIG_fail;
21589 if (obj1) {
21590 {
21591 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21592 if (SWIG_arg_fail(2)) SWIG_fail;
21593 }
21594 }
21595 {
21596 PyThreadState* __tstate = wxPyBeginAllowThreads();
21597 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21598
21599 wxPyEndAllowThreads(__tstate);
21600 if (PyErr_Occurred()) SWIG_fail;
21601 }
21602 {
21603 resultobj = SWIG_From_int((int)(result));
21604 }
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21612 PyObject *resultobj;
21613 wxDateTime *arg1 = (wxDateTime *) 0 ;
21614 bool result;
21615 PyObject * obj0 = 0 ;
21616 char *kwnames[] = {
21617 (char *) "self", NULL
21618 };
21619
21620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21622 if (SWIG_arg_fail(1)) SWIG_fail;
21623 {
21624 PyThreadState* __tstate = wxPyBeginAllowThreads();
21625 result = (bool)((wxDateTime const *)arg1)->IsValid();
21626
21627 wxPyEndAllowThreads(__tstate);
21628 if (PyErr_Occurred()) SWIG_fail;
21629 }
21630 {
21631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21632 }
21633 return resultobj;
21634 fail:
21635 return NULL;
21636 }
21637
21638
21639 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj;
21641 wxDateTime *arg1 = (wxDateTime *) 0 ;
21642 time_t result;
21643 PyObject * obj0 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "self", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21650 if (SWIG_arg_fail(1)) SWIG_fail;
21651 {
21652 PyThreadState* __tstate = wxPyBeginAllowThreads();
21653 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21654
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 {
21659 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21660 }
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxDateTime *arg1 = (wxDateTime *) 0 ;
21670 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21671 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21672 int result;
21673 bool temp2 = false ;
21674 PyObject * obj0 = 0 ;
21675 PyObject * obj1 = 0 ;
21676 char *kwnames[] = {
21677 (char *) "self",(char *) "tz", NULL
21678 };
21679
21680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21682 if (SWIG_arg_fail(1)) SWIG_fail;
21683 if (obj1) {
21684 {
21685 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21686 temp2 = true;
21687 }
21688 }
21689 {
21690 PyThreadState* __tstate = wxPyBeginAllowThreads();
21691 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21692
21693 wxPyEndAllowThreads(__tstate);
21694 if (PyErr_Occurred()) SWIG_fail;
21695 }
21696 {
21697 resultobj = SWIG_From_int((int)(result));
21698 }
21699 {
21700 if (temp2) delete arg2;
21701 }
21702 return resultobj;
21703 fail:
21704 {
21705 if (temp2) delete arg2;
21706 }
21707 return NULL;
21708 }
21709
21710
21711 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21712 PyObject *resultobj;
21713 wxDateTime *arg1 = (wxDateTime *) 0 ;
21714 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21715 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21716 wxDateTime::Month result;
21717 bool temp2 = false ;
21718 PyObject * obj0 = 0 ;
21719 PyObject * obj1 = 0 ;
21720 char *kwnames[] = {
21721 (char *) "self",(char *) "tz", NULL
21722 };
21723
21724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21726 if (SWIG_arg_fail(1)) SWIG_fail;
21727 if (obj1) {
21728 {
21729 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21730 temp2 = true;
21731 }
21732 }
21733 {
21734 PyThreadState* __tstate = wxPyBeginAllowThreads();
21735 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21736
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 resultobj = SWIG_From_int((result));
21741 {
21742 if (temp2) delete arg2;
21743 }
21744 return resultobj;
21745 fail:
21746 {
21747 if (temp2) delete arg2;
21748 }
21749 return NULL;
21750 }
21751
21752
21753 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21754 PyObject *resultobj;
21755 wxDateTime *arg1 = (wxDateTime *) 0 ;
21756 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21757 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21758 int result;
21759 bool temp2 = false ;
21760 PyObject * obj0 = 0 ;
21761 PyObject * obj1 = 0 ;
21762 char *kwnames[] = {
21763 (char *) "self",(char *) "tz", NULL
21764 };
21765
21766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21768 if (SWIG_arg_fail(1)) SWIG_fail;
21769 if (obj1) {
21770 {
21771 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21772 temp2 = true;
21773 }
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 {
21783 resultobj = SWIG_From_int((int)(result));
21784 }
21785 {
21786 if (temp2) delete arg2;
21787 }
21788 return resultobj;
21789 fail:
21790 {
21791 if (temp2) delete arg2;
21792 }
21793 return NULL;
21794 }
21795
21796
21797 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21798 PyObject *resultobj;
21799 wxDateTime *arg1 = (wxDateTime *) 0 ;
21800 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21801 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21802 wxDateTime::WeekDay result;
21803 bool temp2 = false ;
21804 PyObject * obj0 = 0 ;
21805 PyObject * obj1 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self",(char *) "tz", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 if (obj1) {
21814 {
21815 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21816 temp2 = true;
21817 }
21818 }
21819 {
21820 PyThreadState* __tstate = wxPyBeginAllowThreads();
21821 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21822
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 resultobj = SWIG_From_int((result));
21827 {
21828 if (temp2) delete arg2;
21829 }
21830 return resultobj;
21831 fail:
21832 {
21833 if (temp2) delete arg2;
21834 }
21835 return NULL;
21836 }
21837
21838
21839 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21840 PyObject *resultobj;
21841 wxDateTime *arg1 = (wxDateTime *) 0 ;
21842 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21843 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21844 int result;
21845 bool temp2 = false ;
21846 PyObject * obj0 = 0 ;
21847 PyObject * obj1 = 0 ;
21848 char *kwnames[] = {
21849 (char *) "self",(char *) "tz", NULL
21850 };
21851
21852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21854 if (SWIG_arg_fail(1)) SWIG_fail;
21855 if (obj1) {
21856 {
21857 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21858 temp2 = true;
21859 }
21860 }
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21864
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 {
21869 resultobj = SWIG_From_int((int)(result));
21870 }
21871 {
21872 if (temp2) delete arg2;
21873 }
21874 return resultobj;
21875 fail:
21876 {
21877 if (temp2) delete arg2;
21878 }
21879 return NULL;
21880 }
21881
21882
21883 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21884 PyObject *resultobj;
21885 wxDateTime *arg1 = (wxDateTime *) 0 ;
21886 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21887 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21888 int result;
21889 bool temp2 = false ;
21890 PyObject * obj0 = 0 ;
21891 PyObject * obj1 = 0 ;
21892 char *kwnames[] = {
21893 (char *) "self",(char *) "tz", NULL
21894 };
21895
21896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21898 if (SWIG_arg_fail(1)) SWIG_fail;
21899 if (obj1) {
21900 {
21901 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21902 temp2 = true;
21903 }
21904 }
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21908
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 {
21913 resultobj = SWIG_From_int((int)(result));
21914 }
21915 {
21916 if (temp2) delete arg2;
21917 }
21918 return resultobj;
21919 fail:
21920 {
21921 if (temp2) delete arg2;
21922 }
21923 return NULL;
21924 }
21925
21926
21927 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21928 PyObject *resultobj;
21929 wxDateTime *arg1 = (wxDateTime *) 0 ;
21930 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21931 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21932 int result;
21933 bool temp2 = false ;
21934 PyObject * obj0 = 0 ;
21935 PyObject * obj1 = 0 ;
21936 char *kwnames[] = {
21937 (char *) "self",(char *) "tz", NULL
21938 };
21939
21940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21942 if (SWIG_arg_fail(1)) SWIG_fail;
21943 if (obj1) {
21944 {
21945 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21946 temp2 = true;
21947 }
21948 }
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21952
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 {
21957 resultobj = SWIG_From_int((int)(result));
21958 }
21959 {
21960 if (temp2) delete arg2;
21961 }
21962 return resultobj;
21963 fail:
21964 {
21965 if (temp2) delete arg2;
21966 }
21967 return NULL;
21968 }
21969
21970
21971 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21972 PyObject *resultobj;
21973 wxDateTime *arg1 = (wxDateTime *) 0 ;
21974 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21975 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21976 int result;
21977 bool temp2 = false ;
21978 PyObject * obj0 = 0 ;
21979 PyObject * obj1 = 0 ;
21980 char *kwnames[] = {
21981 (char *) "self",(char *) "tz", NULL
21982 };
21983
21984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(1)) SWIG_fail;
21987 if (obj1) {
21988 {
21989 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21990 temp2 = true;
21991 }
21992 }
21993 {
21994 PyThreadState* __tstate = wxPyBeginAllowThreads();
21995 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 {
22001 resultobj = SWIG_From_int((int)(result));
22002 }
22003 {
22004 if (temp2) delete arg2;
22005 }
22006 return resultobj;
22007 fail:
22008 {
22009 if (temp2) delete arg2;
22010 }
22011 return NULL;
22012 }
22013
22014
22015 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj;
22017 wxDateTime *arg1 = (wxDateTime *) 0 ;
22018 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22019 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22020 int result;
22021 bool temp2 = false ;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char *kwnames[] = {
22025 (char *) "self",(char *) "tz", NULL
22026 };
22027
22028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
22029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22030 if (SWIG_arg_fail(1)) SWIG_fail;
22031 if (obj1) {
22032 {
22033 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22034 temp2 = true;
22035 }
22036 }
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
22040
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = SWIG_From_int((int)(result));
22046 }
22047 {
22048 if (temp2) delete arg2;
22049 }
22050 return resultobj;
22051 fail:
22052 {
22053 if (temp2) delete arg2;
22054 }
22055 return NULL;
22056 }
22057
22058
22059 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
22060 PyObject *resultobj;
22061 wxDateTime *arg1 = (wxDateTime *) 0 ;
22062 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22063 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22064 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22065 int result;
22066 bool temp3 = false ;
22067 PyObject * obj0 = 0 ;
22068 PyObject * obj1 = 0 ;
22069 PyObject * obj2 = 0 ;
22070 char *kwnames[] = {
22071 (char *) "self",(char *) "flags",(char *) "tz", NULL
22072 };
22073
22074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
22075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22076 if (SWIG_arg_fail(1)) SWIG_fail;
22077 if (obj1) {
22078 {
22079 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22080 if (SWIG_arg_fail(2)) SWIG_fail;
22081 }
22082 }
22083 if (obj2) {
22084 {
22085 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22086 temp3 = true;
22087 }
22088 }
22089 {
22090 PyThreadState* __tstate = wxPyBeginAllowThreads();
22091 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22092
22093 wxPyEndAllowThreads(__tstate);
22094 if (PyErr_Occurred()) SWIG_fail;
22095 }
22096 {
22097 resultobj = SWIG_From_int((int)(result));
22098 }
22099 {
22100 if (temp3) delete arg3;
22101 }
22102 return resultobj;
22103 fail:
22104 {
22105 if (temp3) delete arg3;
22106 }
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj;
22113 wxDateTime *arg1 = (wxDateTime *) 0 ;
22114 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
22115 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
22116 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
22117 int result;
22118 bool temp3 = false ;
22119 PyObject * obj0 = 0 ;
22120 PyObject * obj1 = 0 ;
22121 PyObject * obj2 = 0 ;
22122 char *kwnames[] = {
22123 (char *) "self",(char *) "flags",(char *) "tz", NULL
22124 };
22125
22126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
22127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22128 if (SWIG_arg_fail(1)) SWIG_fail;
22129 if (obj1) {
22130 {
22131 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
22132 if (SWIG_arg_fail(2)) SWIG_fail;
22133 }
22134 }
22135 if (obj2) {
22136 {
22137 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22138 temp3 = true;
22139 }
22140 }
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 {
22149 resultobj = SWIG_From_int((int)(result));
22150 }
22151 {
22152 if (temp3) delete arg3;
22153 }
22154 return resultobj;
22155 fail:
22156 {
22157 if (temp3) delete arg3;
22158 }
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj;
22165 wxDateTime *arg1 = (wxDateTime *) 0 ;
22166 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22167 bool result;
22168 PyObject * obj0 = 0 ;
22169 PyObject * obj1 = 0 ;
22170 char *kwnames[] = {
22171 (char *) "self",(char *) "country", NULL
22172 };
22173
22174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22176 if (SWIG_arg_fail(1)) SWIG_fail;
22177 if (obj1) {
22178 {
22179 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22180 if (SWIG_arg_fail(2)) SWIG_fail;
22181 }
22182 }
22183 {
22184 PyThreadState* __tstate = wxPyBeginAllowThreads();
22185 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22186
22187 wxPyEndAllowThreads(__tstate);
22188 if (PyErr_Occurred()) SWIG_fail;
22189 }
22190 {
22191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22192 }
22193 return resultobj;
22194 fail:
22195 return NULL;
22196 }
22197
22198
22199 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22200 PyObject *resultobj;
22201 wxDateTime *arg1 = (wxDateTime *) 0 ;
22202 wxDateTime *arg2 = 0 ;
22203 bool result;
22204 PyObject * obj0 = 0 ;
22205 PyObject * obj1 = 0 ;
22206 char *kwnames[] = {
22207 (char *) "self",(char *) "datetime", NULL
22208 };
22209
22210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22212 if (SWIG_arg_fail(1)) SWIG_fail;
22213 {
22214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22215 if (SWIG_arg_fail(2)) SWIG_fail;
22216 if (arg2 == NULL) {
22217 SWIG_null_ref("wxDateTime");
22218 }
22219 if (SWIG_arg_fail(2)) SWIG_fail;
22220 }
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22224
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 {
22229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22230 }
22231 return resultobj;
22232 fail:
22233 return NULL;
22234 }
22235
22236
22237 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22238 PyObject *resultobj;
22239 wxDateTime *arg1 = (wxDateTime *) 0 ;
22240 wxDateTime *arg2 = 0 ;
22241 bool result;
22242 PyObject * obj0 = 0 ;
22243 PyObject * obj1 = 0 ;
22244 char *kwnames[] = {
22245 (char *) "self",(char *) "datetime", NULL
22246 };
22247
22248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22250 if (SWIG_arg_fail(1)) SWIG_fail;
22251 {
22252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22253 if (SWIG_arg_fail(2)) SWIG_fail;
22254 if (arg2 == NULL) {
22255 SWIG_null_ref("wxDateTime");
22256 }
22257 if (SWIG_arg_fail(2)) SWIG_fail;
22258 }
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22262
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 {
22267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22268 }
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj;
22277 wxDateTime *arg1 = (wxDateTime *) 0 ;
22278 wxDateTime *arg2 = 0 ;
22279 bool result;
22280 PyObject * obj0 = 0 ;
22281 PyObject * obj1 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "self",(char *) "datetime", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(1)) SWIG_fail;
22289 {
22290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22291 if (SWIG_arg_fail(2)) SWIG_fail;
22292 if (arg2 == NULL) {
22293 SWIG_null_ref("wxDateTime");
22294 }
22295 if (SWIG_arg_fail(2)) SWIG_fail;
22296 }
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22300
22301 wxPyEndAllowThreads(__tstate);
22302 if (PyErr_Occurred()) SWIG_fail;
22303 }
22304 {
22305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22306 }
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj;
22315 wxDateTime *arg1 = (wxDateTime *) 0 ;
22316 wxDateTime *arg2 = 0 ;
22317 wxDateTime *arg3 = 0 ;
22318 bool result;
22319 PyObject * obj0 = 0 ;
22320 PyObject * obj1 = 0 ;
22321 PyObject * obj2 = 0 ;
22322 char *kwnames[] = {
22323 (char *) "self",(char *) "t1",(char *) "t2", NULL
22324 };
22325
22326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22328 if (SWIG_arg_fail(1)) SWIG_fail;
22329 {
22330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22331 if (SWIG_arg_fail(2)) SWIG_fail;
22332 if (arg2 == NULL) {
22333 SWIG_null_ref("wxDateTime");
22334 }
22335 if (SWIG_arg_fail(2)) SWIG_fail;
22336 }
22337 {
22338 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22339 if (SWIG_arg_fail(3)) SWIG_fail;
22340 if (arg3 == NULL) {
22341 SWIG_null_ref("wxDateTime");
22342 }
22343 if (SWIG_arg_fail(3)) SWIG_fail;
22344 }
22345 {
22346 PyThreadState* __tstate = wxPyBeginAllowThreads();
22347 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22348
22349 wxPyEndAllowThreads(__tstate);
22350 if (PyErr_Occurred()) SWIG_fail;
22351 }
22352 {
22353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22354 }
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22362 PyObject *resultobj;
22363 wxDateTime *arg1 = (wxDateTime *) 0 ;
22364 wxDateTime *arg2 = 0 ;
22365 wxDateTime *arg3 = 0 ;
22366 bool result;
22367 PyObject * obj0 = 0 ;
22368 PyObject * obj1 = 0 ;
22369 PyObject * obj2 = 0 ;
22370 char *kwnames[] = {
22371 (char *) "self",(char *) "t1",(char *) "t2", NULL
22372 };
22373
22374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22376 if (SWIG_arg_fail(1)) SWIG_fail;
22377 {
22378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22379 if (SWIG_arg_fail(2)) SWIG_fail;
22380 if (arg2 == NULL) {
22381 SWIG_null_ref("wxDateTime");
22382 }
22383 if (SWIG_arg_fail(2)) SWIG_fail;
22384 }
22385 {
22386 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22387 if (SWIG_arg_fail(3)) SWIG_fail;
22388 if (arg3 == NULL) {
22389 SWIG_null_ref("wxDateTime");
22390 }
22391 if (SWIG_arg_fail(3)) SWIG_fail;
22392 }
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22396
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 {
22401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22402 }
22403 return resultobj;
22404 fail:
22405 return NULL;
22406 }
22407
22408
22409 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22410 PyObject *resultobj;
22411 wxDateTime *arg1 = (wxDateTime *) 0 ;
22412 wxDateTime *arg2 = 0 ;
22413 bool result;
22414 PyObject * obj0 = 0 ;
22415 PyObject * obj1 = 0 ;
22416 char *kwnames[] = {
22417 (char *) "self",(char *) "dt", NULL
22418 };
22419
22420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22422 if (SWIG_arg_fail(1)) SWIG_fail;
22423 {
22424 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22425 if (SWIG_arg_fail(2)) SWIG_fail;
22426 if (arg2 == NULL) {
22427 SWIG_null_ref("wxDateTime");
22428 }
22429 if (SWIG_arg_fail(2)) SWIG_fail;
22430 }
22431 {
22432 PyThreadState* __tstate = wxPyBeginAllowThreads();
22433 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22434
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 {
22439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22440 }
22441 return resultobj;
22442 fail:
22443 return NULL;
22444 }
22445
22446
22447 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22448 PyObject *resultobj;
22449 wxDateTime *arg1 = (wxDateTime *) 0 ;
22450 wxDateTime *arg2 = 0 ;
22451 bool result;
22452 PyObject * obj0 = 0 ;
22453 PyObject * obj1 = 0 ;
22454 char *kwnames[] = {
22455 (char *) "self",(char *) "dt", NULL
22456 };
22457
22458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22460 if (SWIG_arg_fail(1)) SWIG_fail;
22461 {
22462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22463 if (SWIG_arg_fail(2)) SWIG_fail;
22464 if (arg2 == NULL) {
22465 SWIG_null_ref("wxDateTime");
22466 }
22467 if (SWIG_arg_fail(2)) SWIG_fail;
22468 }
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22472
22473 wxPyEndAllowThreads(__tstate);
22474 if (PyErr_Occurred()) SWIG_fail;
22475 }
22476 {
22477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22478 }
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22486 PyObject *resultobj;
22487 wxDateTime *arg1 = (wxDateTime *) 0 ;
22488 wxDateTime *arg2 = 0 ;
22489 wxTimeSpan *arg3 = 0 ;
22490 bool result;
22491 PyObject * obj0 = 0 ;
22492 PyObject * obj1 = 0 ;
22493 PyObject * obj2 = 0 ;
22494 char *kwnames[] = {
22495 (char *) "self",(char *) "dt",(char *) "ts", NULL
22496 };
22497
22498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22500 if (SWIG_arg_fail(1)) SWIG_fail;
22501 {
22502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22503 if (SWIG_arg_fail(2)) SWIG_fail;
22504 if (arg2 == NULL) {
22505 SWIG_null_ref("wxDateTime");
22506 }
22507 if (SWIG_arg_fail(2)) SWIG_fail;
22508 }
22509 {
22510 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22511 if (SWIG_arg_fail(3)) SWIG_fail;
22512 if (arg3 == NULL) {
22513 SWIG_null_ref("wxTimeSpan");
22514 }
22515 if (SWIG_arg_fail(3)) SWIG_fail;
22516 }
22517 {
22518 PyThreadState* __tstate = wxPyBeginAllowThreads();
22519 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22520
22521 wxPyEndAllowThreads(__tstate);
22522 if (PyErr_Occurred()) SWIG_fail;
22523 }
22524 {
22525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22526 }
22527 return resultobj;
22528 fail:
22529 return NULL;
22530 }
22531
22532
22533 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22534 PyObject *resultobj;
22535 wxDateTime *arg1 = (wxDateTime *) 0 ;
22536 wxTimeSpan *arg2 = 0 ;
22537 wxDateTime *result;
22538 PyObject * obj0 = 0 ;
22539 PyObject * obj1 = 0 ;
22540 char *kwnames[] = {
22541 (char *) "self",(char *) "diff", NULL
22542 };
22543
22544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22546 if (SWIG_arg_fail(1)) SWIG_fail;
22547 {
22548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22549 if (SWIG_arg_fail(2)) SWIG_fail;
22550 if (arg2 == NULL) {
22551 SWIG_null_ref("wxTimeSpan");
22552 }
22553 if (SWIG_arg_fail(2)) SWIG_fail;
22554 }
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 {
22558 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22559 result = (wxDateTime *) &_result_ref;
22560 }
22561
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22573 PyObject *resultobj;
22574 wxDateTime *arg1 = (wxDateTime *) 0 ;
22575 wxDateSpan *arg2 = 0 ;
22576 wxDateTime *result;
22577 PyObject * obj0 = 0 ;
22578 PyObject * obj1 = 0 ;
22579 char *kwnames[] = {
22580 (char *) "self",(char *) "diff", NULL
22581 };
22582
22583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22585 if (SWIG_arg_fail(1)) SWIG_fail;
22586 {
22587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22588 if (SWIG_arg_fail(2)) SWIG_fail;
22589 if (arg2 == NULL) {
22590 SWIG_null_ref("wxDateSpan");
22591 }
22592 if (SWIG_arg_fail(2)) SWIG_fail;
22593 }
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 {
22597 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22598 result = (wxDateTime *) &_result_ref;
22599 }
22600
22601 wxPyEndAllowThreads(__tstate);
22602 if (PyErr_Occurred()) SWIG_fail;
22603 }
22604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22605 return resultobj;
22606 fail:
22607 return NULL;
22608 }
22609
22610
22611 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22612 PyObject *resultobj;
22613 wxDateTime *arg1 = (wxDateTime *) 0 ;
22614 wxTimeSpan *arg2 = 0 ;
22615 wxDateTime *result;
22616 PyObject * obj0 = 0 ;
22617 PyObject * obj1 = 0 ;
22618 char *kwnames[] = {
22619 (char *) "self",(char *) "diff", NULL
22620 };
22621
22622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22624 if (SWIG_arg_fail(1)) SWIG_fail;
22625 {
22626 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22627 if (SWIG_arg_fail(2)) SWIG_fail;
22628 if (arg2 == NULL) {
22629 SWIG_null_ref("wxTimeSpan");
22630 }
22631 if (SWIG_arg_fail(2)) SWIG_fail;
22632 }
22633 {
22634 PyThreadState* __tstate = wxPyBeginAllowThreads();
22635 {
22636 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22637 result = (wxDateTime *) &_result_ref;
22638 }
22639
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22651 PyObject *resultobj;
22652 wxDateTime *arg1 = (wxDateTime *) 0 ;
22653 wxDateSpan *arg2 = 0 ;
22654 wxDateTime *result;
22655 PyObject * obj0 = 0 ;
22656 PyObject * obj1 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self",(char *) "diff", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22666 if (SWIG_arg_fail(2)) SWIG_fail;
22667 if (arg2 == NULL) {
22668 SWIG_null_ref("wxDateSpan");
22669 }
22670 if (SWIG_arg_fail(2)) SWIG_fail;
22671 }
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 {
22675 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22676 result = (wxDateTime *) &_result_ref;
22677 }
22678
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj;
22691 wxDateTime *arg1 = (wxDateTime *) 0 ;
22692 wxDateTime *arg2 = 0 ;
22693 wxTimeSpan result;
22694 PyObject * obj0 = 0 ;
22695 PyObject * obj1 = 0 ;
22696 char *kwnames[] = {
22697 (char *) "self",(char *) "dt", NULL
22698 };
22699
22700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22702 if (SWIG_arg_fail(1)) SWIG_fail;
22703 {
22704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22705 if (SWIG_arg_fail(2)) SWIG_fail;
22706 if (arg2 == NULL) {
22707 SWIG_null_ref("wxDateTime");
22708 }
22709 if (SWIG_arg_fail(2)) SWIG_fail;
22710 }
22711 {
22712 PyThreadState* __tstate = wxPyBeginAllowThreads();
22713 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22714
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 {
22719 wxTimeSpan * resultptr;
22720 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22721 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22722 }
22723 return resultobj;
22724 fail:
22725 return NULL;
22726 }
22727
22728
22729 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22730 PyObject *resultobj;
22731 wxDateTime *arg1 = (wxDateTime *) 0 ;
22732 wxTimeSpan *arg2 = 0 ;
22733 wxDateTime *result;
22734 PyObject * obj0 = 0 ;
22735 PyObject * obj1 = 0 ;
22736
22737 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22739 if (SWIG_arg_fail(1)) SWIG_fail;
22740 {
22741 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22742 if (SWIG_arg_fail(2)) SWIG_fail;
22743 if (arg2 == NULL) {
22744 SWIG_null_ref("wxTimeSpan");
22745 }
22746 if (SWIG_arg_fail(2)) SWIG_fail;
22747 }
22748 {
22749 PyThreadState* __tstate = wxPyBeginAllowThreads();
22750 {
22751 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22752 result = (wxDateTime *) &_result_ref;
22753 }
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22766 PyObject *resultobj;
22767 wxDateTime *arg1 = (wxDateTime *) 0 ;
22768 wxDateSpan *arg2 = 0 ;
22769 wxDateTime *result;
22770 PyObject * obj0 = 0 ;
22771 PyObject * obj1 = 0 ;
22772
22773 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22775 if (SWIG_arg_fail(1)) SWIG_fail;
22776 {
22777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22778 if (SWIG_arg_fail(2)) SWIG_fail;
22779 if (arg2 == NULL) {
22780 SWIG_null_ref("wxDateSpan");
22781 }
22782 if (SWIG_arg_fail(2)) SWIG_fail;
22783 }
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 {
22787 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22788 result = (wxDateTime *) &_result_ref;
22789 }
22790
22791 wxPyEndAllowThreads(__tstate);
22792 if (PyErr_Occurred()) SWIG_fail;
22793 }
22794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22802 int argc;
22803 PyObject *argv[3];
22804 int ii;
22805
22806 argc = PyObject_Length(args);
22807 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22808 argv[ii] = PyTuple_GetItem(args,ii);
22809 }
22810 if (argc == 2) {
22811 int _v;
22812 {
22813 void *ptr;
22814 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22815 _v = 0;
22816 PyErr_Clear();
22817 } else {
22818 _v = 1;
22819 }
22820 }
22821 if (_v) {
22822 {
22823 void *ptr = 0;
22824 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22825 _v = 0;
22826 PyErr_Clear();
22827 } else {
22828 _v = (ptr != 0);
22829 }
22830 }
22831 if (_v) {
22832 return _wrap_DateTime___iadd____SWIG_0(self,args);
22833 }
22834 }
22835 }
22836 if (argc == 2) {
22837 int _v;
22838 {
22839 void *ptr;
22840 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22841 _v = 0;
22842 PyErr_Clear();
22843 } else {
22844 _v = 1;
22845 }
22846 }
22847 if (_v) {
22848 {
22849 void *ptr = 0;
22850 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22851 _v = 0;
22852 PyErr_Clear();
22853 } else {
22854 _v = (ptr != 0);
22855 }
22856 }
22857 if (_v) {
22858 return _wrap_DateTime___iadd____SWIG_1(self,args);
22859 }
22860 }
22861 }
22862
22863 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22864 return NULL;
22865 }
22866
22867
22868 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22869 PyObject *resultobj;
22870 wxDateTime *arg1 = (wxDateTime *) 0 ;
22871 wxTimeSpan *arg2 = 0 ;
22872 wxDateTime *result;
22873 PyObject * obj0 = 0 ;
22874 PyObject * obj1 = 0 ;
22875
22876 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22878 if (SWIG_arg_fail(1)) SWIG_fail;
22879 {
22880 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22881 if (SWIG_arg_fail(2)) SWIG_fail;
22882 if (arg2 == NULL) {
22883 SWIG_null_ref("wxTimeSpan");
22884 }
22885 if (SWIG_arg_fail(2)) SWIG_fail;
22886 }
22887 {
22888 PyThreadState* __tstate = wxPyBeginAllowThreads();
22889 {
22890 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22891 result = (wxDateTime *) &_result_ref;
22892 }
22893
22894 wxPyEndAllowThreads(__tstate);
22895 if (PyErr_Occurred()) SWIG_fail;
22896 }
22897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22898 return resultobj;
22899 fail:
22900 return NULL;
22901 }
22902
22903
22904 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22905 PyObject *resultobj;
22906 wxDateTime *arg1 = (wxDateTime *) 0 ;
22907 wxDateSpan *arg2 = 0 ;
22908 wxDateTime *result;
22909 PyObject * obj0 = 0 ;
22910 PyObject * obj1 = 0 ;
22911
22912 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22914 if (SWIG_arg_fail(1)) SWIG_fail;
22915 {
22916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22917 if (SWIG_arg_fail(2)) SWIG_fail;
22918 if (arg2 == NULL) {
22919 SWIG_null_ref("wxDateSpan");
22920 }
22921 if (SWIG_arg_fail(2)) SWIG_fail;
22922 }
22923 {
22924 PyThreadState* __tstate = wxPyBeginAllowThreads();
22925 {
22926 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22927 result = (wxDateTime *) &_result_ref;
22928 }
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22941 int argc;
22942 PyObject *argv[3];
22943 int ii;
22944
22945 argc = PyObject_Length(args);
22946 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22947 argv[ii] = PyTuple_GetItem(args,ii);
22948 }
22949 if (argc == 2) {
22950 int _v;
22951 {
22952 void *ptr;
22953 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22954 _v = 0;
22955 PyErr_Clear();
22956 } else {
22957 _v = 1;
22958 }
22959 }
22960 if (_v) {
22961 {
22962 void *ptr = 0;
22963 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22964 _v = 0;
22965 PyErr_Clear();
22966 } else {
22967 _v = (ptr != 0);
22968 }
22969 }
22970 if (_v) {
22971 return _wrap_DateTime___isub____SWIG_0(self,args);
22972 }
22973 }
22974 }
22975 if (argc == 2) {
22976 int _v;
22977 {
22978 void *ptr;
22979 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22980 _v = 0;
22981 PyErr_Clear();
22982 } else {
22983 _v = 1;
22984 }
22985 }
22986 if (_v) {
22987 {
22988 void *ptr = 0;
22989 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22990 _v = 0;
22991 PyErr_Clear();
22992 } else {
22993 _v = (ptr != 0);
22994 }
22995 }
22996 if (_v) {
22997 return _wrap_DateTime___isub____SWIG_1(self,args);
22998 }
22999 }
23000 }
23001
23002 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
23003 return NULL;
23004 }
23005
23006
23007 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
23008 PyObject *resultobj;
23009 wxDateTime *arg1 = (wxDateTime *) 0 ;
23010 wxTimeSpan *arg2 = 0 ;
23011 wxDateTime result;
23012 PyObject * obj0 = 0 ;
23013 PyObject * obj1 = 0 ;
23014
23015 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23017 if (SWIG_arg_fail(1)) SWIG_fail;
23018 {
23019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23020 if (SWIG_arg_fail(2)) SWIG_fail;
23021 if (arg2 == NULL) {
23022 SWIG_null_ref("wxTimeSpan");
23023 }
23024 if (SWIG_arg_fail(2)) SWIG_fail;
23025 }
23026 {
23027 PyThreadState* __tstate = wxPyBeginAllowThreads();
23028 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
23029
23030 wxPyEndAllowThreads(__tstate);
23031 if (PyErr_Occurred()) SWIG_fail;
23032 }
23033 {
23034 wxDateTime * resultptr;
23035 resultptr = new wxDateTime((wxDateTime &)(result));
23036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23037 }
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
23045 PyObject *resultobj;
23046 wxDateTime *arg1 = (wxDateTime *) 0 ;
23047 wxDateSpan *arg2 = 0 ;
23048 wxDateTime result;
23049 PyObject * obj0 = 0 ;
23050 PyObject * obj1 = 0 ;
23051
23052 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
23053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23054 if (SWIG_arg_fail(1)) SWIG_fail;
23055 {
23056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23057 if (SWIG_arg_fail(2)) SWIG_fail;
23058 if (arg2 == NULL) {
23059 SWIG_null_ref("wxDateSpan");
23060 }
23061 if (SWIG_arg_fail(2)) SWIG_fail;
23062 }
23063 {
23064 PyThreadState* __tstate = wxPyBeginAllowThreads();
23065 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
23066
23067 wxPyEndAllowThreads(__tstate);
23068 if (PyErr_Occurred()) SWIG_fail;
23069 }
23070 {
23071 wxDateTime * resultptr;
23072 resultptr = new wxDateTime((wxDateTime &)(result));
23073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
23082 int argc;
23083 PyObject *argv[3];
23084 int ii;
23085
23086 argc = PyObject_Length(args);
23087 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23088 argv[ii] = PyTuple_GetItem(args,ii);
23089 }
23090 if (argc == 2) {
23091 int _v;
23092 {
23093 void *ptr;
23094 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23095 _v = 0;
23096 PyErr_Clear();
23097 } else {
23098 _v = 1;
23099 }
23100 }
23101 if (_v) {
23102 {
23103 void *ptr = 0;
23104 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23105 _v = 0;
23106 PyErr_Clear();
23107 } else {
23108 _v = (ptr != 0);
23109 }
23110 }
23111 if (_v) {
23112 return _wrap_DateTime___add____SWIG_0(self,args);
23113 }
23114 }
23115 }
23116 if (argc == 2) {
23117 int _v;
23118 {
23119 void *ptr;
23120 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23121 _v = 0;
23122 PyErr_Clear();
23123 } else {
23124 _v = 1;
23125 }
23126 }
23127 if (_v) {
23128 {
23129 void *ptr = 0;
23130 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23131 _v = 0;
23132 PyErr_Clear();
23133 } else {
23134 _v = (ptr != 0);
23135 }
23136 }
23137 if (_v) {
23138 return _wrap_DateTime___add____SWIG_1(self,args);
23139 }
23140 }
23141 }
23142
23143 Py_INCREF(Py_NotImplemented);
23144 return Py_NotImplemented;
23145 }
23146
23147
23148 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23149 PyObject *resultobj;
23150 wxDateTime *arg1 = (wxDateTime *) 0 ;
23151 wxDateTime *arg2 = 0 ;
23152 wxTimeSpan result;
23153 PyObject * obj0 = 0 ;
23154 PyObject * obj1 = 0 ;
23155
23156 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23158 if (SWIG_arg_fail(1)) SWIG_fail;
23159 {
23160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23161 if (SWIG_arg_fail(2)) SWIG_fail;
23162 if (arg2 == NULL) {
23163 SWIG_null_ref("wxDateTime");
23164 }
23165 if (SWIG_arg_fail(2)) SWIG_fail;
23166 }
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23170
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 {
23175 wxTimeSpan * resultptr;
23176 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23178 }
23179 return resultobj;
23180 fail:
23181 return NULL;
23182 }
23183
23184
23185 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23186 PyObject *resultobj;
23187 wxDateTime *arg1 = (wxDateTime *) 0 ;
23188 wxTimeSpan *arg2 = 0 ;
23189 wxDateTime result;
23190 PyObject * obj0 = 0 ;
23191 PyObject * obj1 = 0 ;
23192
23193 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23195 if (SWIG_arg_fail(1)) SWIG_fail;
23196 {
23197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23198 if (SWIG_arg_fail(2)) SWIG_fail;
23199 if (arg2 == NULL) {
23200 SWIG_null_ref("wxTimeSpan");
23201 }
23202 if (SWIG_arg_fail(2)) SWIG_fail;
23203 }
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23207
23208 wxPyEndAllowThreads(__tstate);
23209 if (PyErr_Occurred()) SWIG_fail;
23210 }
23211 {
23212 wxDateTime * resultptr;
23213 resultptr = new wxDateTime((wxDateTime &)(result));
23214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23215 }
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23223 PyObject *resultobj;
23224 wxDateTime *arg1 = (wxDateTime *) 0 ;
23225 wxDateSpan *arg2 = 0 ;
23226 wxDateTime result;
23227 PyObject * obj0 = 0 ;
23228 PyObject * obj1 = 0 ;
23229
23230 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23232 if (SWIG_arg_fail(1)) SWIG_fail;
23233 {
23234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23235 if (SWIG_arg_fail(2)) SWIG_fail;
23236 if (arg2 == NULL) {
23237 SWIG_null_ref("wxDateSpan");
23238 }
23239 if (SWIG_arg_fail(2)) SWIG_fail;
23240 }
23241 {
23242 PyThreadState* __tstate = wxPyBeginAllowThreads();
23243 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23244
23245 wxPyEndAllowThreads(__tstate);
23246 if (PyErr_Occurred()) SWIG_fail;
23247 }
23248 {
23249 wxDateTime * resultptr;
23250 resultptr = new wxDateTime((wxDateTime &)(result));
23251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23252 }
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23260 int argc;
23261 PyObject *argv[3];
23262 int ii;
23263
23264 argc = PyObject_Length(args);
23265 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23266 argv[ii] = PyTuple_GetItem(args,ii);
23267 }
23268 if (argc == 2) {
23269 int _v;
23270 {
23271 void *ptr;
23272 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23273 _v = 0;
23274 PyErr_Clear();
23275 } else {
23276 _v = 1;
23277 }
23278 }
23279 if (_v) {
23280 {
23281 void *ptr = 0;
23282 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23283 _v = 0;
23284 PyErr_Clear();
23285 } else {
23286 _v = (ptr != 0);
23287 }
23288 }
23289 if (_v) {
23290 return _wrap_DateTime___sub____SWIG_0(self,args);
23291 }
23292 }
23293 }
23294 if (argc == 2) {
23295 int _v;
23296 {
23297 void *ptr;
23298 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23299 _v = 0;
23300 PyErr_Clear();
23301 } else {
23302 _v = 1;
23303 }
23304 }
23305 if (_v) {
23306 {
23307 void *ptr = 0;
23308 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23309 _v = 0;
23310 PyErr_Clear();
23311 } else {
23312 _v = (ptr != 0);
23313 }
23314 }
23315 if (_v) {
23316 return _wrap_DateTime___sub____SWIG_1(self,args);
23317 }
23318 }
23319 }
23320 if (argc == 2) {
23321 int _v;
23322 {
23323 void *ptr;
23324 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23325 _v = 0;
23326 PyErr_Clear();
23327 } else {
23328 _v = 1;
23329 }
23330 }
23331 if (_v) {
23332 {
23333 void *ptr = 0;
23334 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23335 _v = 0;
23336 PyErr_Clear();
23337 } else {
23338 _v = (ptr != 0);
23339 }
23340 }
23341 if (_v) {
23342 return _wrap_DateTime___sub____SWIG_2(self,args);
23343 }
23344 }
23345 }
23346
23347 Py_INCREF(Py_NotImplemented);
23348 return Py_NotImplemented;
23349 }
23350
23351
23352 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23353 PyObject *resultobj;
23354 wxDateTime *arg1 = (wxDateTime *) 0 ;
23355 wxDateTime *arg2 = (wxDateTime *) 0 ;
23356 bool result;
23357 PyObject * obj0 = 0 ;
23358 PyObject * obj1 = 0 ;
23359 char *kwnames[] = {
23360 (char *) "self",(char *) "other", NULL
23361 };
23362
23363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23365 if (SWIG_arg_fail(1)) SWIG_fail;
23366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23367 if (SWIG_arg_fail(2)) SWIG_fail;
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23371
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 {
23376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23377 }
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23385 PyObject *resultobj;
23386 wxDateTime *arg1 = (wxDateTime *) 0 ;
23387 wxDateTime *arg2 = (wxDateTime *) 0 ;
23388 bool result;
23389 PyObject * obj0 = 0 ;
23390 PyObject * obj1 = 0 ;
23391 char *kwnames[] = {
23392 (char *) "self",(char *) "other", NULL
23393 };
23394
23395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23397 if (SWIG_arg_fail(1)) SWIG_fail;
23398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23399 if (SWIG_arg_fail(2)) SWIG_fail;
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23403
23404 wxPyEndAllowThreads(__tstate);
23405 if (PyErr_Occurred()) SWIG_fail;
23406 }
23407 {
23408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23409 }
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23417 PyObject *resultobj;
23418 wxDateTime *arg1 = (wxDateTime *) 0 ;
23419 wxDateTime *arg2 = (wxDateTime *) 0 ;
23420 bool result;
23421 PyObject * obj0 = 0 ;
23422 PyObject * obj1 = 0 ;
23423 char *kwnames[] = {
23424 (char *) "self",(char *) "other", NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23429 if (SWIG_arg_fail(1)) SWIG_fail;
23430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23431 if (SWIG_arg_fail(2)) SWIG_fail;
23432 {
23433 PyThreadState* __tstate = wxPyBeginAllowThreads();
23434 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23435
23436 wxPyEndAllowThreads(__tstate);
23437 if (PyErr_Occurred()) SWIG_fail;
23438 }
23439 {
23440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23441 }
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj;
23450 wxDateTime *arg1 = (wxDateTime *) 0 ;
23451 wxDateTime *arg2 = (wxDateTime *) 0 ;
23452 bool result;
23453 PyObject * obj0 = 0 ;
23454 PyObject * obj1 = 0 ;
23455 char *kwnames[] = {
23456 (char *) "self",(char *) "other", NULL
23457 };
23458
23459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23461 if (SWIG_arg_fail(1)) SWIG_fail;
23462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(2)) SWIG_fail;
23464 {
23465 PyThreadState* __tstate = wxPyBeginAllowThreads();
23466 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23467
23468 wxPyEndAllowThreads(__tstate);
23469 if (PyErr_Occurred()) SWIG_fail;
23470 }
23471 {
23472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23473 }
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxDateTime *arg1 = (wxDateTime *) 0 ;
23483 wxDateTime *arg2 = (wxDateTime *) 0 ;
23484 bool result;
23485 PyObject * obj0 = 0 ;
23486 PyObject * obj1 = 0 ;
23487 char *kwnames[] = {
23488 (char *) "self",(char *) "other", NULL
23489 };
23490
23491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23493 if (SWIG_arg_fail(1)) SWIG_fail;
23494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23495 if (SWIG_arg_fail(2)) SWIG_fail;
23496 {
23497 PyThreadState* __tstate = wxPyBeginAllowThreads();
23498 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23499
23500 wxPyEndAllowThreads(__tstate);
23501 if (PyErr_Occurred()) SWIG_fail;
23502 }
23503 {
23504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23505 }
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23513 PyObject *resultobj;
23514 wxDateTime *arg1 = (wxDateTime *) 0 ;
23515 wxDateTime *arg2 = (wxDateTime *) 0 ;
23516 bool result;
23517 PyObject * obj0 = 0 ;
23518 PyObject * obj1 = 0 ;
23519 char *kwnames[] = {
23520 (char *) "self",(char *) "other", NULL
23521 };
23522
23523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23525 if (SWIG_arg_fail(1)) SWIG_fail;
23526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23527 if (SWIG_arg_fail(2)) SWIG_fail;
23528 {
23529 PyThreadState* __tstate = wxPyBeginAllowThreads();
23530 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23531
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 {
23536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23537 }
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj;
23546 wxDateTime *arg1 = (wxDateTime *) 0 ;
23547 wxString *arg2 = 0 ;
23548 int result;
23549 bool temp2 = false ;
23550 PyObject * obj0 = 0 ;
23551 PyObject * obj1 = 0 ;
23552 char *kwnames[] = {
23553 (char *) "self",(char *) "date", NULL
23554 };
23555
23556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23558 if (SWIG_arg_fail(1)) SWIG_fail;
23559 {
23560 arg2 = wxString_in_helper(obj1);
23561 if (arg2 == NULL) SWIG_fail;
23562 temp2 = true;
23563 }
23564 {
23565 PyThreadState* __tstate = wxPyBeginAllowThreads();
23566 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23567
23568 wxPyEndAllowThreads(__tstate);
23569 if (PyErr_Occurred()) SWIG_fail;
23570 }
23571 {
23572 resultobj = SWIG_From_int((int)(result));
23573 }
23574 {
23575 if (temp2)
23576 delete arg2;
23577 }
23578 return resultobj;
23579 fail:
23580 {
23581 if (temp2)
23582 delete arg2;
23583 }
23584 return NULL;
23585 }
23586
23587
23588 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23589 PyObject *resultobj;
23590 wxDateTime *arg1 = (wxDateTime *) 0 ;
23591 wxString *arg2 = 0 ;
23592 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23593 wxString *arg3 = (wxString *) &arg3_defvalue ;
23594 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23595 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23596 int result;
23597 bool temp2 = false ;
23598 bool temp3 = false ;
23599 PyObject * obj0 = 0 ;
23600 PyObject * obj1 = 0 ;
23601 PyObject * obj2 = 0 ;
23602 PyObject * obj3 = 0 ;
23603 char *kwnames[] = {
23604 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23605 };
23606
23607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23609 if (SWIG_arg_fail(1)) SWIG_fail;
23610 {
23611 arg2 = wxString_in_helper(obj1);
23612 if (arg2 == NULL) SWIG_fail;
23613 temp2 = true;
23614 }
23615 if (obj2) {
23616 {
23617 arg3 = wxString_in_helper(obj2);
23618 if (arg3 == NULL) SWIG_fail;
23619 temp3 = true;
23620 }
23621 }
23622 if (obj3) {
23623 {
23624 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23625 if (SWIG_arg_fail(4)) SWIG_fail;
23626 if (arg4 == NULL) {
23627 SWIG_null_ref("wxDateTime");
23628 }
23629 if (SWIG_arg_fail(4)) SWIG_fail;
23630 }
23631 }
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 {
23640 resultobj = SWIG_From_int((int)(result));
23641 }
23642 {
23643 if (temp2)
23644 delete arg2;
23645 }
23646 {
23647 if (temp3)
23648 delete arg3;
23649 }
23650 return resultobj;
23651 fail:
23652 {
23653 if (temp2)
23654 delete arg2;
23655 }
23656 {
23657 if (temp3)
23658 delete arg3;
23659 }
23660 return NULL;
23661 }
23662
23663
23664 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23665 PyObject *resultobj;
23666 wxDateTime *arg1 = (wxDateTime *) 0 ;
23667 wxString *arg2 = 0 ;
23668 int result;
23669 bool temp2 = false ;
23670 PyObject * obj0 = 0 ;
23671 PyObject * obj1 = 0 ;
23672 char *kwnames[] = {
23673 (char *) "self",(char *) "datetime", NULL
23674 };
23675
23676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23678 if (SWIG_arg_fail(1)) SWIG_fail;
23679 {
23680 arg2 = wxString_in_helper(obj1);
23681 if (arg2 == NULL) SWIG_fail;
23682 temp2 = true;
23683 }
23684 {
23685 PyThreadState* __tstate = wxPyBeginAllowThreads();
23686 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23687
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 {
23692 resultobj = SWIG_From_int((int)(result));
23693 }
23694 {
23695 if (temp2)
23696 delete arg2;
23697 }
23698 return resultobj;
23699 fail:
23700 {
23701 if (temp2)
23702 delete arg2;
23703 }
23704 return NULL;
23705 }
23706
23707
23708 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23709 PyObject *resultobj;
23710 wxDateTime *arg1 = (wxDateTime *) 0 ;
23711 wxString *arg2 = 0 ;
23712 int result;
23713 bool temp2 = false ;
23714 PyObject * obj0 = 0 ;
23715 PyObject * obj1 = 0 ;
23716 char *kwnames[] = {
23717 (char *) "self",(char *) "date", NULL
23718 };
23719
23720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23722 if (SWIG_arg_fail(1)) SWIG_fail;
23723 {
23724 arg2 = wxString_in_helper(obj1);
23725 if (arg2 == NULL) SWIG_fail;
23726 temp2 = true;
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23731
23732 wxPyEndAllowThreads(__tstate);
23733 if (PyErr_Occurred()) SWIG_fail;
23734 }
23735 {
23736 resultobj = SWIG_From_int((int)(result));
23737 }
23738 {
23739 if (temp2)
23740 delete arg2;
23741 }
23742 return resultobj;
23743 fail:
23744 {
23745 if (temp2)
23746 delete arg2;
23747 }
23748 return NULL;
23749 }
23750
23751
23752 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj;
23754 wxDateTime *arg1 = (wxDateTime *) 0 ;
23755 wxString *arg2 = 0 ;
23756 int result;
23757 bool temp2 = false ;
23758 PyObject * obj0 = 0 ;
23759 PyObject * obj1 = 0 ;
23760 char *kwnames[] = {
23761 (char *) "self",(char *) "time", NULL
23762 };
23763
23764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23766 if (SWIG_arg_fail(1)) SWIG_fail;
23767 {
23768 arg2 = wxString_in_helper(obj1);
23769 if (arg2 == NULL) SWIG_fail;
23770 temp2 = true;
23771 }
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23775
23776 wxPyEndAllowThreads(__tstate);
23777 if (PyErr_Occurred()) SWIG_fail;
23778 }
23779 {
23780 resultobj = SWIG_From_int((int)(result));
23781 }
23782 {
23783 if (temp2)
23784 delete arg2;
23785 }
23786 return resultobj;
23787 fail:
23788 {
23789 if (temp2)
23790 delete arg2;
23791 }
23792 return NULL;
23793 }
23794
23795
23796 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23797 PyObject *resultobj;
23798 wxDateTime *arg1 = (wxDateTime *) 0 ;
23799 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23800 wxString *arg2 = (wxString *) &arg2_defvalue ;
23801 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23802 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23803 wxString result;
23804 bool temp2 = false ;
23805 bool temp3 = false ;
23806 PyObject * obj0 = 0 ;
23807 PyObject * obj1 = 0 ;
23808 PyObject * obj2 = 0 ;
23809 char *kwnames[] = {
23810 (char *) "self",(char *) "format",(char *) "tz", NULL
23811 };
23812
23813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23815 if (SWIG_arg_fail(1)) SWIG_fail;
23816 if (obj1) {
23817 {
23818 arg2 = wxString_in_helper(obj1);
23819 if (arg2 == NULL) SWIG_fail;
23820 temp2 = true;
23821 }
23822 }
23823 if (obj2) {
23824 {
23825 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23826 temp3 = true;
23827 }
23828 }
23829 {
23830 PyThreadState* __tstate = wxPyBeginAllowThreads();
23831 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23832
23833 wxPyEndAllowThreads(__tstate);
23834 if (PyErr_Occurred()) SWIG_fail;
23835 }
23836 {
23837 #if wxUSE_UNICODE
23838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23839 #else
23840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23841 #endif
23842 }
23843 {
23844 if (temp2)
23845 delete arg2;
23846 }
23847 {
23848 if (temp3) delete arg3;
23849 }
23850 return resultobj;
23851 fail:
23852 {
23853 if (temp2)
23854 delete arg2;
23855 }
23856 {
23857 if (temp3) delete arg3;
23858 }
23859 return NULL;
23860 }
23861
23862
23863 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj;
23865 wxDateTime *arg1 = (wxDateTime *) 0 ;
23866 wxString result;
23867 PyObject * obj0 = 0 ;
23868 char *kwnames[] = {
23869 (char *) "self", NULL
23870 };
23871
23872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23874 if (SWIG_arg_fail(1)) SWIG_fail;
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 result = ((wxDateTime const *)arg1)->FormatDate();
23878
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 {
23883 #if wxUSE_UNICODE
23884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23885 #else
23886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23887 #endif
23888 }
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj;
23897 wxDateTime *arg1 = (wxDateTime *) 0 ;
23898 wxString result;
23899 PyObject * obj0 = 0 ;
23900 char *kwnames[] = {
23901 (char *) "self", NULL
23902 };
23903
23904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23906 if (SWIG_arg_fail(1)) SWIG_fail;
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = ((wxDateTime const *)arg1)->FormatTime();
23910
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 #if wxUSE_UNICODE
23916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23917 #else
23918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23919 #endif
23920 }
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23928 PyObject *resultobj;
23929 wxDateTime *arg1 = (wxDateTime *) 0 ;
23930 wxString result;
23931 PyObject * obj0 = 0 ;
23932 char *kwnames[] = {
23933 (char *) "self", NULL
23934 };
23935
23936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23938 if (SWIG_arg_fail(1)) SWIG_fail;
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 result = ((wxDateTime const *)arg1)->FormatISODate();
23942
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 {
23947 #if wxUSE_UNICODE
23948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23949 #else
23950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23951 #endif
23952 }
23953 return resultobj;
23954 fail:
23955 return NULL;
23956 }
23957
23958
23959 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23960 PyObject *resultobj;
23961 wxDateTime *arg1 = (wxDateTime *) 0 ;
23962 wxString result;
23963 PyObject * obj0 = 0 ;
23964 char *kwnames[] = {
23965 (char *) "self", NULL
23966 };
23967
23968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23970 if (SWIG_arg_fail(1)) SWIG_fail;
23971 {
23972 PyThreadState* __tstate = wxPyBeginAllowThreads();
23973 result = ((wxDateTime const *)arg1)->FormatISOTime();
23974
23975 wxPyEndAllowThreads(__tstate);
23976 if (PyErr_Occurred()) SWIG_fail;
23977 }
23978 {
23979 #if wxUSE_UNICODE
23980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23981 #else
23982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23983 #endif
23984 }
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23992 PyObject *obj;
23993 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23994 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23995 Py_INCREF(obj);
23996 return Py_BuildValue((char *)"");
23997 }
23998 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj;
24000 long arg1 ;
24001 wxTimeSpan result;
24002 PyObject * obj0 = 0 ;
24003 char *kwnames[] = {
24004 (char *) "sec", NULL
24005 };
24006
24007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
24008 {
24009 arg1 = (long)(SWIG_As_long(obj0));
24010 if (SWIG_arg_fail(1)) SWIG_fail;
24011 }
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 result = wxTimeSpan::Seconds(arg1);
24015
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 {
24020 wxTimeSpan * resultptr;
24021 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24023 }
24024 return resultobj;
24025 fail:
24026 return NULL;
24027 }
24028
24029
24030 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj;
24032 wxTimeSpan result;
24033 char *kwnames[] = {
24034 NULL
24035 };
24036
24037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = wxTimeSpan::Second();
24041
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 {
24046 wxTimeSpan * resultptr;
24047 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24049 }
24050 return resultobj;
24051 fail:
24052 return NULL;
24053 }
24054
24055
24056 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
24057 PyObject *resultobj;
24058 long arg1 ;
24059 wxTimeSpan result;
24060 PyObject * obj0 = 0 ;
24061 char *kwnames[] = {
24062 (char *) "min", NULL
24063 };
24064
24065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
24066 {
24067 arg1 = (long)(SWIG_As_long(obj0));
24068 if (SWIG_arg_fail(1)) SWIG_fail;
24069 }
24070 {
24071 PyThreadState* __tstate = wxPyBeginAllowThreads();
24072 result = wxTimeSpan::Minutes(arg1);
24073
24074 wxPyEndAllowThreads(__tstate);
24075 if (PyErr_Occurred()) SWIG_fail;
24076 }
24077 {
24078 wxTimeSpan * resultptr;
24079 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24081 }
24082 return resultobj;
24083 fail:
24084 return NULL;
24085 }
24086
24087
24088 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
24089 PyObject *resultobj;
24090 wxTimeSpan result;
24091 char *kwnames[] = {
24092 NULL
24093 };
24094
24095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
24096 {
24097 PyThreadState* __tstate = wxPyBeginAllowThreads();
24098 result = wxTimeSpan::Minute();
24099
24100 wxPyEndAllowThreads(__tstate);
24101 if (PyErr_Occurred()) SWIG_fail;
24102 }
24103 {
24104 wxTimeSpan * resultptr;
24105 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24106 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24107 }
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj;
24116 long arg1 ;
24117 wxTimeSpan result;
24118 PyObject * obj0 = 0 ;
24119 char *kwnames[] = {
24120 (char *) "hours", NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
24124 {
24125 arg1 = (long)(SWIG_As_long(obj0));
24126 if (SWIG_arg_fail(1)) SWIG_fail;
24127 }
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = wxTimeSpan::Hours(arg1);
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_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24147 PyObject *resultobj;
24148 wxTimeSpan result;
24149 char *kwnames[] = {
24150 NULL
24151 };
24152
24153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = wxTimeSpan::Hour();
24157
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 {
24162 wxTimeSpan * resultptr;
24163 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24173 PyObject *resultobj;
24174 long arg1 ;
24175 wxTimeSpan result;
24176 PyObject * obj0 = 0 ;
24177 char *kwnames[] = {
24178 (char *) "days", NULL
24179 };
24180
24181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24182 {
24183 arg1 = (long)(SWIG_As_long(obj0));
24184 if (SWIG_arg_fail(1)) SWIG_fail;
24185 }
24186 {
24187 PyThreadState* __tstate = wxPyBeginAllowThreads();
24188 result = wxTimeSpan::Days(arg1);
24189
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 {
24194 wxTimeSpan * resultptr;
24195 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24197 }
24198 return resultobj;
24199 fail:
24200 return NULL;
24201 }
24202
24203
24204 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24205 PyObject *resultobj;
24206 wxTimeSpan result;
24207 char *kwnames[] = {
24208 NULL
24209 };
24210
24211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24212 {
24213 PyThreadState* __tstate = wxPyBeginAllowThreads();
24214 result = wxTimeSpan::Day();
24215
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 {
24220 wxTimeSpan * resultptr;
24221 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24223 }
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 long arg1 ;
24233 wxTimeSpan result;
24234 PyObject * obj0 = 0 ;
24235 char *kwnames[] = {
24236 (char *) "days", NULL
24237 };
24238
24239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24240 {
24241 arg1 = (long)(SWIG_As_long(obj0));
24242 if (SWIG_arg_fail(1)) SWIG_fail;
24243 }
24244 {
24245 PyThreadState* __tstate = wxPyBeginAllowThreads();
24246 result = wxTimeSpan::Weeks(arg1);
24247
24248 wxPyEndAllowThreads(__tstate);
24249 if (PyErr_Occurred()) SWIG_fail;
24250 }
24251 {
24252 wxTimeSpan * resultptr;
24253 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24255 }
24256 return resultobj;
24257 fail:
24258 return NULL;
24259 }
24260
24261
24262 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24263 PyObject *resultobj;
24264 wxTimeSpan result;
24265 char *kwnames[] = {
24266 NULL
24267 };
24268
24269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 result = wxTimeSpan::Week();
24273
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 {
24278 wxTimeSpan * resultptr;
24279 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24281 }
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24289 PyObject *resultobj;
24290 long arg1 = (long) 0 ;
24291 long arg2 = (long) 0 ;
24292 long arg3 = (long) 0 ;
24293 long arg4 = (long) 0 ;
24294 wxTimeSpan *result;
24295 PyObject * obj0 = 0 ;
24296 PyObject * obj1 = 0 ;
24297 PyObject * obj2 = 0 ;
24298 PyObject * obj3 = 0 ;
24299 char *kwnames[] = {
24300 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24301 };
24302
24303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24304 if (obj0) {
24305 {
24306 arg1 = (long)(SWIG_As_long(obj0));
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 }
24309 }
24310 if (obj1) {
24311 {
24312 arg2 = (long)(SWIG_As_long(obj1));
24313 if (SWIG_arg_fail(2)) SWIG_fail;
24314 }
24315 }
24316 if (obj2) {
24317 {
24318 arg3 = (long)(SWIG_As_long(obj2));
24319 if (SWIG_arg_fail(3)) SWIG_fail;
24320 }
24321 }
24322 if (obj3) {
24323 {
24324 arg4 = (long)(SWIG_As_long(obj3));
24325 if (SWIG_arg_fail(4)) SWIG_fail;
24326 }
24327 }
24328 {
24329 PyThreadState* __tstate = wxPyBeginAllowThreads();
24330 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24331
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24343 PyObject *resultobj;
24344 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24345 PyObject * obj0 = 0 ;
24346 char *kwnames[] = {
24347 (char *) "self", NULL
24348 };
24349
24350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24352 if (SWIG_arg_fail(1)) SWIG_fail;
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 delete arg1;
24356
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 Py_INCREF(Py_None); resultobj = Py_None;
24361 return resultobj;
24362 fail:
24363 return NULL;
24364 }
24365
24366
24367 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24368 PyObject *resultobj;
24369 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24370 wxTimeSpan *arg2 = 0 ;
24371 wxTimeSpan *result;
24372 PyObject * obj0 = 0 ;
24373 PyObject * obj1 = 0 ;
24374 char *kwnames[] = {
24375 (char *) "self",(char *) "diff", NULL
24376 };
24377
24378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24380 if (SWIG_arg_fail(1)) SWIG_fail;
24381 {
24382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24383 if (SWIG_arg_fail(2)) SWIG_fail;
24384 if (arg2 == NULL) {
24385 SWIG_null_ref("wxTimeSpan");
24386 }
24387 if (SWIG_arg_fail(2)) SWIG_fail;
24388 }
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 {
24392 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24393 result = (wxTimeSpan *) &_result_ref;
24394 }
24395
24396 wxPyEndAllowThreads(__tstate);
24397 if (PyErr_Occurred()) SWIG_fail;
24398 }
24399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24400 return resultobj;
24401 fail:
24402 return NULL;
24403 }
24404
24405
24406 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj;
24408 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24409 wxTimeSpan *arg2 = 0 ;
24410 wxTimeSpan *result;
24411 PyObject * obj0 = 0 ;
24412 PyObject * obj1 = 0 ;
24413 char *kwnames[] = {
24414 (char *) "self",(char *) "diff", NULL
24415 };
24416
24417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24419 if (SWIG_arg_fail(1)) SWIG_fail;
24420 {
24421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 if (arg2 == NULL) {
24424 SWIG_null_ref("wxTimeSpan");
24425 }
24426 if (SWIG_arg_fail(2)) SWIG_fail;
24427 }
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 {
24431 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24432 result = (wxTimeSpan *) &_result_ref;
24433 }
24434
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24446 PyObject *resultobj;
24447 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24448 int arg2 ;
24449 wxTimeSpan *result;
24450 PyObject * obj0 = 0 ;
24451 PyObject * obj1 = 0 ;
24452 char *kwnames[] = {
24453 (char *) "self",(char *) "n", NULL
24454 };
24455
24456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24458 if (SWIG_arg_fail(1)) SWIG_fail;
24459 {
24460 arg2 = (int)(SWIG_As_int(obj1));
24461 if (SWIG_arg_fail(2)) SWIG_fail;
24462 }
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 {
24466 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24467 result = (wxTimeSpan *) &_result_ref;
24468 }
24469
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj;
24482 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24483 wxTimeSpan *result;
24484 PyObject * obj0 = 0 ;
24485 char *kwnames[] = {
24486 (char *) "self", NULL
24487 };
24488
24489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24491 if (SWIG_arg_fail(1)) SWIG_fail;
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 {
24495 wxTimeSpan &_result_ref = (arg1)->Neg();
24496 result = (wxTimeSpan *) &_result_ref;
24497 }
24498
24499 wxPyEndAllowThreads(__tstate);
24500 if (PyErr_Occurred()) SWIG_fail;
24501 }
24502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24503 return resultobj;
24504 fail:
24505 return NULL;
24506 }
24507
24508
24509 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24510 PyObject *resultobj;
24511 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24512 wxTimeSpan result;
24513 PyObject * obj0 = 0 ;
24514 char *kwnames[] = {
24515 (char *) "self", NULL
24516 };
24517
24518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24520 if (SWIG_arg_fail(1)) SWIG_fail;
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 result = ((wxTimeSpan const *)arg1)->Abs();
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 {
24529 wxTimeSpan * resultptr;
24530 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24532 }
24533 return resultobj;
24534 fail:
24535 return NULL;
24536 }
24537
24538
24539 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj;
24541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24542 wxTimeSpan *arg2 = 0 ;
24543 wxTimeSpan *result;
24544 PyObject * obj0 = 0 ;
24545 PyObject * obj1 = 0 ;
24546 char *kwnames[] = {
24547 (char *) "self",(char *) "diff", NULL
24548 };
24549
24550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24552 if (SWIG_arg_fail(1)) SWIG_fail;
24553 {
24554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24555 if (SWIG_arg_fail(2)) SWIG_fail;
24556 if (arg2 == NULL) {
24557 SWIG_null_ref("wxTimeSpan");
24558 }
24559 if (SWIG_arg_fail(2)) SWIG_fail;
24560 }
24561 {
24562 PyThreadState* __tstate = wxPyBeginAllowThreads();
24563 {
24564 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24565 result = (wxTimeSpan *) &_result_ref;
24566 }
24567
24568 wxPyEndAllowThreads(__tstate);
24569 if (PyErr_Occurred()) SWIG_fail;
24570 }
24571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24572 return resultobj;
24573 fail:
24574 return NULL;
24575 }
24576
24577
24578 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24579 PyObject *resultobj;
24580 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24581 wxTimeSpan *arg2 = 0 ;
24582 wxTimeSpan *result;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char *kwnames[] = {
24586 (char *) "self",(char *) "diff", NULL
24587 };
24588
24589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24591 if (SWIG_arg_fail(1)) SWIG_fail;
24592 {
24593 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24594 if (SWIG_arg_fail(2)) SWIG_fail;
24595 if (arg2 == NULL) {
24596 SWIG_null_ref("wxTimeSpan");
24597 }
24598 if (SWIG_arg_fail(2)) SWIG_fail;
24599 }
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 {
24603 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24604 result = (wxTimeSpan *) &_result_ref;
24605 }
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24611 return resultobj;
24612 fail:
24613 return NULL;
24614 }
24615
24616
24617 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24618 PyObject *resultobj;
24619 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24620 int arg2 ;
24621 wxTimeSpan *result;
24622 PyObject * obj0 = 0 ;
24623 PyObject * obj1 = 0 ;
24624 char *kwnames[] = {
24625 (char *) "self",(char *) "n", NULL
24626 };
24627
24628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24630 if (SWIG_arg_fail(1)) SWIG_fail;
24631 {
24632 arg2 = (int)(SWIG_As_int(obj1));
24633 if (SWIG_arg_fail(2)) SWIG_fail;
24634 }
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 {
24638 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24639 result = (wxTimeSpan *) &_result_ref;
24640 }
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj;
24654 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24655 wxTimeSpan *result;
24656 PyObject * obj0 = 0 ;
24657 char *kwnames[] = {
24658 (char *) "self", NULL
24659 };
24660
24661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24663 if (SWIG_arg_fail(1)) SWIG_fail;
24664 {
24665 PyThreadState* __tstate = wxPyBeginAllowThreads();
24666 {
24667 wxTimeSpan &_result_ref = (arg1)->operator -();
24668 result = (wxTimeSpan *) &_result_ref;
24669 }
24670
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj;
24683 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24684 wxTimeSpan *arg2 = 0 ;
24685 wxTimeSpan result;
24686 PyObject * obj0 = 0 ;
24687 PyObject * obj1 = 0 ;
24688 char *kwnames[] = {
24689 (char *) "self",(char *) "other", NULL
24690 };
24691
24692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24694 if (SWIG_arg_fail(1)) SWIG_fail;
24695 {
24696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(2)) SWIG_fail;
24698 if (arg2 == NULL) {
24699 SWIG_null_ref("wxTimeSpan");
24700 }
24701 if (SWIG_arg_fail(2)) SWIG_fail;
24702 }
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24706
24707 wxPyEndAllowThreads(__tstate);
24708 if (PyErr_Occurred()) SWIG_fail;
24709 }
24710 {
24711 wxTimeSpan * resultptr;
24712 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24714 }
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24722 PyObject *resultobj;
24723 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24724 wxTimeSpan *arg2 = 0 ;
24725 wxTimeSpan result;
24726 PyObject * obj0 = 0 ;
24727 PyObject * obj1 = 0 ;
24728 char *kwnames[] = {
24729 (char *) "self",(char *) "other", NULL
24730 };
24731
24732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24734 if (SWIG_arg_fail(1)) SWIG_fail;
24735 {
24736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(2)) SWIG_fail;
24738 if (arg2 == NULL) {
24739 SWIG_null_ref("wxTimeSpan");
24740 }
24741 if (SWIG_arg_fail(2)) SWIG_fail;
24742 }
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24746
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 {
24751 wxTimeSpan * resultptr;
24752 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24753 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24754 }
24755 return resultobj;
24756 fail:
24757 return NULL;
24758 }
24759
24760
24761 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24762 PyObject *resultobj;
24763 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24764 int arg2 ;
24765 wxTimeSpan result;
24766 PyObject * obj0 = 0 ;
24767 PyObject * obj1 = 0 ;
24768 char *kwnames[] = {
24769 (char *) "self",(char *) "n", NULL
24770 };
24771
24772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24774 if (SWIG_arg_fail(1)) SWIG_fail;
24775 {
24776 arg2 = (int)(SWIG_As_int(obj1));
24777 if (SWIG_arg_fail(2)) SWIG_fail;
24778 }
24779 {
24780 PyThreadState* __tstate = wxPyBeginAllowThreads();
24781 result = wxTimeSpan___mul__(arg1,arg2);
24782
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 wxTimeSpan * resultptr;
24788 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24790 }
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24798 PyObject *resultobj;
24799 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24800 int arg2 ;
24801 wxTimeSpan result;
24802 PyObject * obj0 = 0 ;
24803 PyObject * obj1 = 0 ;
24804 char *kwnames[] = {
24805 (char *) "self",(char *) "n", NULL
24806 };
24807
24808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24810 if (SWIG_arg_fail(1)) SWIG_fail;
24811 {
24812 arg2 = (int)(SWIG_As_int(obj1));
24813 if (SWIG_arg_fail(2)) SWIG_fail;
24814 }
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = wxTimeSpan___rmul__(arg1,arg2);
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 {
24823 wxTimeSpan * resultptr;
24824 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24826 }
24827 return resultobj;
24828 fail:
24829 return NULL;
24830 }
24831
24832
24833 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24834 PyObject *resultobj;
24835 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24836 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24837 bool result;
24838 PyObject * obj0 = 0 ;
24839 PyObject * obj1 = 0 ;
24840 char *kwnames[] = {
24841 (char *) "self",(char *) "other", NULL
24842 };
24843
24844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24846 if (SWIG_arg_fail(1)) SWIG_fail;
24847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24848 if (SWIG_arg_fail(2)) SWIG_fail;
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24852
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 {
24857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24858 }
24859 return resultobj;
24860 fail:
24861 return NULL;
24862 }
24863
24864
24865 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24866 PyObject *resultobj;
24867 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24868 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24869 bool result;
24870 PyObject * obj0 = 0 ;
24871 PyObject * obj1 = 0 ;
24872 char *kwnames[] = {
24873 (char *) "self",(char *) "other", NULL
24874 };
24875
24876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24878 if (SWIG_arg_fail(1)) SWIG_fail;
24879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24880 if (SWIG_arg_fail(2)) SWIG_fail;
24881 {
24882 PyThreadState* __tstate = wxPyBeginAllowThreads();
24883 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24884
24885 wxPyEndAllowThreads(__tstate);
24886 if (PyErr_Occurred()) SWIG_fail;
24887 }
24888 {
24889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24890 }
24891 return resultobj;
24892 fail:
24893 return NULL;
24894 }
24895
24896
24897 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24898 PyObject *resultobj;
24899 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24900 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24901 bool result;
24902 PyObject * obj0 = 0 ;
24903 PyObject * obj1 = 0 ;
24904 char *kwnames[] = {
24905 (char *) "self",(char *) "other", NULL
24906 };
24907
24908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24910 if (SWIG_arg_fail(1)) SWIG_fail;
24911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24912 if (SWIG_arg_fail(2)) SWIG_fail;
24913 {
24914 PyThreadState* __tstate = wxPyBeginAllowThreads();
24915 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24916
24917 wxPyEndAllowThreads(__tstate);
24918 if (PyErr_Occurred()) SWIG_fail;
24919 }
24920 {
24921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24922 }
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj;
24931 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24932 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24933 bool result;
24934 PyObject * obj0 = 0 ;
24935 PyObject * obj1 = 0 ;
24936 char *kwnames[] = {
24937 (char *) "self",(char *) "other", NULL
24938 };
24939
24940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24942 if (SWIG_arg_fail(1)) SWIG_fail;
24943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24944 if (SWIG_arg_fail(2)) SWIG_fail;
24945 {
24946 PyThreadState* __tstate = wxPyBeginAllowThreads();
24947 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24948
24949 wxPyEndAllowThreads(__tstate);
24950 if (PyErr_Occurred()) SWIG_fail;
24951 }
24952 {
24953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24954 }
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj;
24963 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24964 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24965 bool result;
24966 PyObject * obj0 = 0 ;
24967 PyObject * obj1 = 0 ;
24968 char *kwnames[] = {
24969 (char *) "self",(char *) "other", NULL
24970 };
24971
24972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24974 if (SWIG_arg_fail(1)) SWIG_fail;
24975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24976 if (SWIG_arg_fail(2)) SWIG_fail;
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24980
24981 wxPyEndAllowThreads(__tstate);
24982 if (PyErr_Occurred()) SWIG_fail;
24983 }
24984 {
24985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24986 }
24987 return resultobj;
24988 fail:
24989 return NULL;
24990 }
24991
24992
24993 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24994 PyObject *resultobj;
24995 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24996 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24997 bool result;
24998 PyObject * obj0 = 0 ;
24999 PyObject * obj1 = 0 ;
25000 char *kwnames[] = {
25001 (char *) "self",(char *) "other", NULL
25002 };
25003
25004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25006 if (SWIG_arg_fail(1)) SWIG_fail;
25007 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25008 if (SWIG_arg_fail(2)) SWIG_fail;
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
25012
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 {
25017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25018 }
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
25026 PyObject *resultobj;
25027 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25028 bool result;
25029 PyObject * obj0 = 0 ;
25030 char *kwnames[] = {
25031 (char *) "self", NULL
25032 };
25033
25034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
25035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25036 if (SWIG_arg_fail(1)) SWIG_fail;
25037 {
25038 PyThreadState* __tstate = wxPyBeginAllowThreads();
25039 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
25040
25041 wxPyEndAllowThreads(__tstate);
25042 if (PyErr_Occurred()) SWIG_fail;
25043 }
25044 {
25045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25046 }
25047 return resultobj;
25048 fail:
25049 return NULL;
25050 }
25051
25052
25053 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
25054 PyObject *resultobj;
25055 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25056 bool result;
25057 PyObject * obj0 = 0 ;
25058 char *kwnames[] = {
25059 (char *) "self", NULL
25060 };
25061
25062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
25063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25064 if (SWIG_arg_fail(1)) SWIG_fail;
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
25068
25069 wxPyEndAllowThreads(__tstate);
25070 if (PyErr_Occurred()) SWIG_fail;
25071 }
25072 {
25073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25074 }
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj;
25083 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25084 bool result;
25085 PyObject * obj0 = 0 ;
25086 char *kwnames[] = {
25087 (char *) "self", NULL
25088 };
25089
25090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
25091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25092 if (SWIG_arg_fail(1)) SWIG_fail;
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
25096
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
25110 PyObject *resultobj;
25111 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25112 wxTimeSpan *arg2 = 0 ;
25113 bool result;
25114 PyObject * obj0 = 0 ;
25115 PyObject * obj1 = 0 ;
25116 char *kwnames[] = {
25117 (char *) "self",(char *) "ts", NULL
25118 };
25119
25120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
25121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25122 if (SWIG_arg_fail(1)) SWIG_fail;
25123 {
25124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(2)) SWIG_fail;
25126 if (arg2 == NULL) {
25127 SWIG_null_ref("wxTimeSpan");
25128 }
25129 if (SWIG_arg_fail(2)) SWIG_fail;
25130 }
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
25134
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 {
25139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25140 }
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25148 PyObject *resultobj;
25149 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25150 wxTimeSpan *arg2 = 0 ;
25151 bool result;
25152 PyObject * obj0 = 0 ;
25153 PyObject * obj1 = 0 ;
25154 char *kwnames[] = {
25155 (char *) "self",(char *) "ts", NULL
25156 };
25157
25158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25160 if (SWIG_arg_fail(1)) SWIG_fail;
25161 {
25162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25163 if (SWIG_arg_fail(2)) SWIG_fail;
25164 if (arg2 == NULL) {
25165 SWIG_null_ref("wxTimeSpan");
25166 }
25167 if (SWIG_arg_fail(2)) SWIG_fail;
25168 }
25169 {
25170 PyThreadState* __tstate = wxPyBeginAllowThreads();
25171 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25172
25173 wxPyEndAllowThreads(__tstate);
25174 if (PyErr_Occurred()) SWIG_fail;
25175 }
25176 {
25177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25178 }
25179 return resultobj;
25180 fail:
25181 return NULL;
25182 }
25183
25184
25185 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj;
25187 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25188 wxTimeSpan *arg2 = 0 ;
25189 bool result;
25190 PyObject * obj0 = 0 ;
25191 PyObject * obj1 = 0 ;
25192 char *kwnames[] = {
25193 (char *) "self",(char *) "t", NULL
25194 };
25195
25196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25198 if (SWIG_arg_fail(1)) SWIG_fail;
25199 {
25200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25201 if (SWIG_arg_fail(2)) SWIG_fail;
25202 if (arg2 == NULL) {
25203 SWIG_null_ref("wxTimeSpan");
25204 }
25205 if (SWIG_arg_fail(2)) SWIG_fail;
25206 }
25207 {
25208 PyThreadState* __tstate = wxPyBeginAllowThreads();
25209 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25210
25211 wxPyEndAllowThreads(__tstate);
25212 if (PyErr_Occurred()) SWIG_fail;
25213 }
25214 {
25215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25216 }
25217 return resultobj;
25218 fail:
25219 return NULL;
25220 }
25221
25222
25223 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25224 PyObject *resultobj;
25225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25226 int result;
25227 PyObject * obj0 = 0 ;
25228 char *kwnames[] = {
25229 (char *) "self", NULL
25230 };
25231
25232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25234 if (SWIG_arg_fail(1)) SWIG_fail;
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25238
25239 wxPyEndAllowThreads(__tstate);
25240 if (PyErr_Occurred()) SWIG_fail;
25241 }
25242 {
25243 resultobj = SWIG_From_int((int)(result));
25244 }
25245 return resultobj;
25246 fail:
25247 return NULL;
25248 }
25249
25250
25251 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj;
25253 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25254 int result;
25255 PyObject * obj0 = 0 ;
25256 char *kwnames[] = {
25257 (char *) "self", NULL
25258 };
25259
25260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25262 if (SWIG_arg_fail(1)) SWIG_fail;
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25266
25267 wxPyEndAllowThreads(__tstate);
25268 if (PyErr_Occurred()) SWIG_fail;
25269 }
25270 {
25271 resultobj = SWIG_From_int((int)(result));
25272 }
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25280 PyObject *resultobj;
25281 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25282 int result;
25283 PyObject * obj0 = 0 ;
25284 char *kwnames[] = {
25285 (char *) "self", NULL
25286 };
25287
25288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25290 if (SWIG_arg_fail(1)) SWIG_fail;
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25294
25295 wxPyEndAllowThreads(__tstate);
25296 if (PyErr_Occurred()) SWIG_fail;
25297 }
25298 {
25299 resultobj = SWIG_From_int((int)(result));
25300 }
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25308 PyObject *resultobj;
25309 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25310 int result;
25311 PyObject * obj0 = 0 ;
25312 char *kwnames[] = {
25313 (char *) "self", NULL
25314 };
25315
25316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25318 if (SWIG_arg_fail(1)) SWIG_fail;
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25322
25323 wxPyEndAllowThreads(__tstate);
25324 if (PyErr_Occurred()) SWIG_fail;
25325 }
25326 {
25327 resultobj = SWIG_From_int((int)(result));
25328 }
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25336 PyObject *resultobj;
25337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25338 wxLongLong result;
25339 PyObject * obj0 = 0 ;
25340 char *kwnames[] = {
25341 (char *) "self", NULL
25342 };
25343
25344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25346 if (SWIG_arg_fail(1)) SWIG_fail;
25347 {
25348 PyThreadState* __tstate = wxPyBeginAllowThreads();
25349 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25350
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 {
25355 PyObject *hi, *lo, *shifter, *shifted;
25356 hi = PyLong_FromLong( (&result)->GetHi() );
25357 lo = PyLong_FromLong( (&result)->GetLo() );
25358 shifter = PyLong_FromLong(32);
25359 shifted = PyNumber_Lshift(hi, shifter);
25360 resultobj = PyNumber_Or(shifted, lo);
25361 Py_DECREF(hi);
25362 Py_DECREF(lo);
25363 Py_DECREF(shifter);
25364 Py_DECREF(shifted);
25365 }
25366 return resultobj;
25367 fail:
25368 return NULL;
25369 }
25370
25371
25372 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25373 PyObject *resultobj;
25374 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25375 wxLongLong result;
25376 PyObject * obj0 = 0 ;
25377 char *kwnames[] = {
25378 (char *) "self", NULL
25379 };
25380
25381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25383 if (SWIG_arg_fail(1)) SWIG_fail;
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25387
25388 wxPyEndAllowThreads(__tstate);
25389 if (PyErr_Occurred()) SWIG_fail;
25390 }
25391 {
25392 PyObject *hi, *lo, *shifter, *shifted;
25393 hi = PyLong_FromLong( (&result)->GetHi() );
25394 lo = PyLong_FromLong( (&result)->GetLo() );
25395 shifter = PyLong_FromLong(32);
25396 shifted = PyNumber_Lshift(hi, shifter);
25397 resultobj = PyNumber_Or(shifted, lo);
25398 Py_DECREF(hi);
25399 Py_DECREF(lo);
25400 Py_DECREF(shifter);
25401 Py_DECREF(shifted);
25402 }
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj;
25411 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25412 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25413 wxString *arg2 = (wxString *) &arg2_defvalue ;
25414 wxString result;
25415 bool temp2 = false ;
25416 PyObject * obj0 = 0 ;
25417 PyObject * obj1 = 0 ;
25418 char *kwnames[] = {
25419 (char *) "self",(char *) "format", NULL
25420 };
25421
25422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25424 if (SWIG_arg_fail(1)) SWIG_fail;
25425 if (obj1) {
25426 {
25427 arg2 = wxString_in_helper(obj1);
25428 if (arg2 == NULL) SWIG_fail;
25429 temp2 = true;
25430 }
25431 }
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25435
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 {
25440 #if wxUSE_UNICODE
25441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25442 #else
25443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25444 #endif
25445 }
25446 {
25447 if (temp2)
25448 delete arg2;
25449 }
25450 return resultobj;
25451 fail:
25452 {
25453 if (temp2)
25454 delete arg2;
25455 }
25456 return NULL;
25457 }
25458
25459
25460 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25461 PyObject *obj;
25462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25463 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25464 Py_INCREF(obj);
25465 return Py_BuildValue((char *)"");
25466 }
25467 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj;
25469 int arg1 = (int) 0 ;
25470 int arg2 = (int) 0 ;
25471 int arg3 = (int) 0 ;
25472 int arg4 = (int) 0 ;
25473 wxDateSpan *result;
25474 PyObject * obj0 = 0 ;
25475 PyObject * obj1 = 0 ;
25476 PyObject * obj2 = 0 ;
25477 PyObject * obj3 = 0 ;
25478 char *kwnames[] = {
25479 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25480 };
25481
25482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25483 if (obj0) {
25484 {
25485 arg1 = (int)(SWIG_As_int(obj0));
25486 if (SWIG_arg_fail(1)) SWIG_fail;
25487 }
25488 }
25489 if (obj1) {
25490 {
25491 arg2 = (int)(SWIG_As_int(obj1));
25492 if (SWIG_arg_fail(2)) SWIG_fail;
25493 }
25494 }
25495 if (obj2) {
25496 {
25497 arg3 = (int)(SWIG_As_int(obj2));
25498 if (SWIG_arg_fail(3)) SWIG_fail;
25499 }
25500 }
25501 if (obj3) {
25502 {
25503 arg4 = (int)(SWIG_As_int(obj3));
25504 if (SWIG_arg_fail(4)) SWIG_fail;
25505 }
25506 }
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25524 PyObject * obj0 = 0 ;
25525 char *kwnames[] = {
25526 (char *) "self", NULL
25527 };
25528
25529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25531 if (SWIG_arg_fail(1)) SWIG_fail;
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 delete arg1;
25535
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 Py_INCREF(Py_None); resultobj = Py_None;
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 int arg1 ;
25549 wxDateSpan result;
25550 PyObject * obj0 = 0 ;
25551 char *kwnames[] = {
25552 (char *) "days", NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25556 {
25557 arg1 = (int)(SWIG_As_int(obj0));
25558 if (SWIG_arg_fail(1)) SWIG_fail;
25559 }
25560 {
25561 PyThreadState* __tstate = wxPyBeginAllowThreads();
25562 result = wxDateSpan::Days(arg1);
25563
25564 wxPyEndAllowThreads(__tstate);
25565 if (PyErr_Occurred()) SWIG_fail;
25566 }
25567 {
25568 wxDateSpan * resultptr;
25569 resultptr = new wxDateSpan((wxDateSpan &)(result));
25570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25571 }
25572 return resultobj;
25573 fail:
25574 return NULL;
25575 }
25576
25577
25578 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25579 PyObject *resultobj;
25580 wxDateSpan result;
25581 char *kwnames[] = {
25582 NULL
25583 };
25584
25585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = wxDateSpan::Day();
25589
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 {
25594 wxDateSpan * resultptr;
25595 resultptr = new wxDateSpan((wxDateSpan &)(result));
25596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25605 PyObject *resultobj;
25606 int arg1 ;
25607 wxDateSpan result;
25608 PyObject * obj0 = 0 ;
25609 char *kwnames[] = {
25610 (char *) "weeks", NULL
25611 };
25612
25613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25614 {
25615 arg1 = (int)(SWIG_As_int(obj0));
25616 if (SWIG_arg_fail(1)) SWIG_fail;
25617 }
25618 {
25619 PyThreadState* __tstate = wxPyBeginAllowThreads();
25620 result = wxDateSpan::Weeks(arg1);
25621
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 {
25626 wxDateSpan * resultptr;
25627 resultptr = new wxDateSpan((wxDateSpan &)(result));
25628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25629 }
25630 return resultobj;
25631 fail:
25632 return NULL;
25633 }
25634
25635
25636 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25637 PyObject *resultobj;
25638 wxDateSpan result;
25639 char *kwnames[] = {
25640 NULL
25641 };
25642
25643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = wxDateSpan::Week();
25647
25648 wxPyEndAllowThreads(__tstate);
25649 if (PyErr_Occurred()) SWIG_fail;
25650 }
25651 {
25652 wxDateSpan * resultptr;
25653 resultptr = new wxDateSpan((wxDateSpan &)(result));
25654 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25655 }
25656 return resultobj;
25657 fail:
25658 return NULL;
25659 }
25660
25661
25662 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25663 PyObject *resultobj;
25664 int arg1 ;
25665 wxDateSpan result;
25666 PyObject * obj0 = 0 ;
25667 char *kwnames[] = {
25668 (char *) "mon", NULL
25669 };
25670
25671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25672 {
25673 arg1 = (int)(SWIG_As_int(obj0));
25674 if (SWIG_arg_fail(1)) SWIG_fail;
25675 }
25676 {
25677 PyThreadState* __tstate = wxPyBeginAllowThreads();
25678 result = wxDateSpan::Months(arg1);
25679
25680 wxPyEndAllowThreads(__tstate);
25681 if (PyErr_Occurred()) SWIG_fail;
25682 }
25683 {
25684 wxDateSpan * resultptr;
25685 resultptr = new wxDateSpan((wxDateSpan &)(result));
25686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25687 }
25688 return resultobj;
25689 fail:
25690 return NULL;
25691 }
25692
25693
25694 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25695 PyObject *resultobj;
25696 wxDateSpan result;
25697 char *kwnames[] = {
25698 NULL
25699 };
25700
25701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = wxDateSpan::Month();
25705
25706 wxPyEndAllowThreads(__tstate);
25707 if (PyErr_Occurred()) SWIG_fail;
25708 }
25709 {
25710 wxDateSpan * resultptr;
25711 resultptr = new wxDateSpan((wxDateSpan &)(result));
25712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25713 }
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj;
25722 int arg1 ;
25723 wxDateSpan result;
25724 PyObject * obj0 = 0 ;
25725 char *kwnames[] = {
25726 (char *) "years", NULL
25727 };
25728
25729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25730 {
25731 arg1 = (int)(SWIG_As_int(obj0));
25732 if (SWIG_arg_fail(1)) SWIG_fail;
25733 }
25734 {
25735 PyThreadState* __tstate = wxPyBeginAllowThreads();
25736 result = wxDateSpan::Years(arg1);
25737
25738 wxPyEndAllowThreads(__tstate);
25739 if (PyErr_Occurred()) SWIG_fail;
25740 }
25741 {
25742 wxDateSpan * resultptr;
25743 resultptr = new wxDateSpan((wxDateSpan &)(result));
25744 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25745 }
25746 return resultobj;
25747 fail:
25748 return NULL;
25749 }
25750
25751
25752 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25753 PyObject *resultobj;
25754 wxDateSpan result;
25755 char *kwnames[] = {
25756 NULL
25757 };
25758
25759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25760 {
25761 PyThreadState* __tstate = wxPyBeginAllowThreads();
25762 result = wxDateSpan::Year();
25763
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 {
25768 wxDateSpan * resultptr;
25769 resultptr = new wxDateSpan((wxDateSpan &)(result));
25770 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25771 }
25772 return resultobj;
25773 fail:
25774 return NULL;
25775 }
25776
25777
25778 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25779 PyObject *resultobj;
25780 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25781 int arg2 ;
25782 wxDateSpan *result;
25783 PyObject * obj0 = 0 ;
25784 PyObject * obj1 = 0 ;
25785 char *kwnames[] = {
25786 (char *) "self",(char *) "n", NULL
25787 };
25788
25789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25791 if (SWIG_arg_fail(1)) SWIG_fail;
25792 {
25793 arg2 = (int)(SWIG_As_int(obj1));
25794 if (SWIG_arg_fail(2)) SWIG_fail;
25795 }
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 {
25799 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25800 result = (wxDateSpan *) &_result_ref;
25801 }
25802
25803 wxPyEndAllowThreads(__tstate);
25804 if (PyErr_Occurred()) SWIG_fail;
25805 }
25806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj;
25815 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25816 int arg2 ;
25817 wxDateSpan *result;
25818 PyObject * obj0 = 0 ;
25819 PyObject * obj1 = 0 ;
25820 char *kwnames[] = {
25821 (char *) "self",(char *) "n", NULL
25822 };
25823
25824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25826 if (SWIG_arg_fail(1)) SWIG_fail;
25827 {
25828 arg2 = (int)(SWIG_As_int(obj1));
25829 if (SWIG_arg_fail(2)) SWIG_fail;
25830 }
25831 {
25832 PyThreadState* __tstate = wxPyBeginAllowThreads();
25833 {
25834 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25835 result = (wxDateSpan *) &_result_ref;
25836 }
25837
25838 wxPyEndAllowThreads(__tstate);
25839 if (PyErr_Occurred()) SWIG_fail;
25840 }
25841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25842 return resultobj;
25843 fail:
25844 return NULL;
25845 }
25846
25847
25848 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25849 PyObject *resultobj;
25850 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25851 int arg2 ;
25852 wxDateSpan *result;
25853 PyObject * obj0 = 0 ;
25854 PyObject * obj1 = 0 ;
25855 char *kwnames[] = {
25856 (char *) "self",(char *) "n", NULL
25857 };
25858
25859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25861 if (SWIG_arg_fail(1)) SWIG_fail;
25862 {
25863 arg2 = (int)(SWIG_As_int(obj1));
25864 if (SWIG_arg_fail(2)) SWIG_fail;
25865 }
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 {
25869 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25870 result = (wxDateSpan *) &_result_ref;
25871 }
25872
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj;
25885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25886 int arg2 ;
25887 wxDateSpan *result;
25888 PyObject * obj0 = 0 ;
25889 PyObject * obj1 = 0 ;
25890 char *kwnames[] = {
25891 (char *) "self",(char *) "n", NULL
25892 };
25893
25894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25896 if (SWIG_arg_fail(1)) SWIG_fail;
25897 {
25898 arg2 = (int)(SWIG_As_int(obj1));
25899 if (SWIG_arg_fail(2)) SWIG_fail;
25900 }
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 {
25904 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25905 result = (wxDateSpan *) &_result_ref;
25906 }
25907
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj;
25920 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25921 int result;
25922 PyObject * obj0 = 0 ;
25923 char *kwnames[] = {
25924 (char *) "self", NULL
25925 };
25926
25927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25929 if (SWIG_arg_fail(1)) SWIG_fail;
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = (int)((wxDateSpan const *)arg1)->GetYears();
25933
25934 wxPyEndAllowThreads(__tstate);
25935 if (PyErr_Occurred()) SWIG_fail;
25936 }
25937 {
25938 resultobj = SWIG_From_int((int)(result));
25939 }
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj;
25948 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25949 int result;
25950 PyObject * obj0 = 0 ;
25951 char *kwnames[] = {
25952 (char *) "self", NULL
25953 };
25954
25955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25957 if (SWIG_arg_fail(1)) SWIG_fail;
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25961
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 {
25966 resultobj = SWIG_From_int((int)(result));
25967 }
25968 return resultobj;
25969 fail:
25970 return NULL;
25971 }
25972
25973
25974 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25975 PyObject *resultobj;
25976 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25977 int result;
25978 PyObject * obj0 = 0 ;
25979 char *kwnames[] = {
25980 (char *) "self", NULL
25981 };
25982
25983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25985 if (SWIG_arg_fail(1)) SWIG_fail;
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25989
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 {
25994 resultobj = SWIG_From_int((int)(result));
25995 }
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj;
26004 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26005 int result;
26006 PyObject * obj0 = 0 ;
26007 char *kwnames[] = {
26008 (char *) "self", NULL
26009 };
26010
26011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
26012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26013 if (SWIG_arg_fail(1)) SWIG_fail;
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 result = (int)((wxDateSpan const *)arg1)->GetDays();
26017
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 {
26022 resultobj = SWIG_From_int((int)(result));
26023 }
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
26031 PyObject *resultobj;
26032 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26033 int result;
26034 PyObject * obj0 = 0 ;
26035 char *kwnames[] = {
26036 (char *) "self", NULL
26037 };
26038
26039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
26040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26041 if (SWIG_arg_fail(1)) SWIG_fail;
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
26045
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 {
26050 resultobj = SWIG_From_int((int)(result));
26051 }
26052 return resultobj;
26053 fail:
26054 return NULL;
26055 }
26056
26057
26058 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
26059 PyObject *resultobj;
26060 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26061 wxDateSpan *arg2 = 0 ;
26062 wxDateSpan *result;
26063 PyObject * obj0 = 0 ;
26064 PyObject * obj1 = 0 ;
26065 char *kwnames[] = {
26066 (char *) "self",(char *) "other", NULL
26067 };
26068
26069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
26070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26071 if (SWIG_arg_fail(1)) SWIG_fail;
26072 {
26073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26074 if (SWIG_arg_fail(2)) SWIG_fail;
26075 if (arg2 == NULL) {
26076 SWIG_null_ref("wxDateSpan");
26077 }
26078 if (SWIG_arg_fail(2)) SWIG_fail;
26079 }
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 {
26083 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26084 result = (wxDateSpan *) &_result_ref;
26085 }
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj;
26099 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26100 wxDateSpan *arg2 = 0 ;
26101 wxDateSpan *result;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char *kwnames[] = {
26105 (char *) "self",(char *) "other", NULL
26106 };
26107
26108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
26109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26110 if (SWIG_arg_fail(1)) SWIG_fail;
26111 {
26112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26113 if (SWIG_arg_fail(2)) SWIG_fail;
26114 if (arg2 == NULL) {
26115 SWIG_null_ref("wxDateSpan");
26116 }
26117 if (SWIG_arg_fail(2)) SWIG_fail;
26118 }
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 {
26122 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26123 result = (wxDateSpan *) &_result_ref;
26124 }
26125
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj;
26138 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26139 wxDateSpan *result;
26140 PyObject * obj0 = 0 ;
26141 char *kwnames[] = {
26142 (char *) "self", NULL
26143 };
26144
26145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26147 if (SWIG_arg_fail(1)) SWIG_fail;
26148 {
26149 PyThreadState* __tstate = wxPyBeginAllowThreads();
26150 {
26151 wxDateSpan &_result_ref = (arg1)->Neg();
26152 result = (wxDateSpan *) &_result_ref;
26153 }
26154
26155 wxPyEndAllowThreads(__tstate);
26156 if (PyErr_Occurred()) SWIG_fail;
26157 }
26158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26166 PyObject *resultobj;
26167 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26168 int arg2 ;
26169 wxDateSpan *result;
26170 PyObject * obj0 = 0 ;
26171 PyObject * obj1 = 0 ;
26172 char *kwnames[] = {
26173 (char *) "self",(char *) "factor", NULL
26174 };
26175
26176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26178 if (SWIG_arg_fail(1)) SWIG_fail;
26179 {
26180 arg2 = (int)(SWIG_As_int(obj1));
26181 if (SWIG_arg_fail(2)) SWIG_fail;
26182 }
26183 {
26184 PyThreadState* __tstate = wxPyBeginAllowThreads();
26185 {
26186 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26187 result = (wxDateSpan *) &_result_ref;
26188 }
26189
26190 wxPyEndAllowThreads(__tstate);
26191 if (PyErr_Occurred()) SWIG_fail;
26192 }
26193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26203 wxDateSpan *arg2 = 0 ;
26204 wxDateSpan *result;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char *kwnames[] = {
26208 (char *) "self",(char *) "other", NULL
26209 };
26210
26211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26213 if (SWIG_arg_fail(1)) SWIG_fail;
26214 {
26215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 if (arg2 == NULL) {
26218 SWIG_null_ref("wxDateSpan");
26219 }
26220 if (SWIG_arg_fail(2)) SWIG_fail;
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 {
26225 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26226 result = (wxDateSpan *) &_result_ref;
26227 }
26228
26229 wxPyEndAllowThreads(__tstate);
26230 if (PyErr_Occurred()) SWIG_fail;
26231 }
26232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26233 return resultobj;
26234 fail:
26235 return NULL;
26236 }
26237
26238
26239 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26240 PyObject *resultobj;
26241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26242 wxDateSpan *arg2 = 0 ;
26243 wxDateSpan *result;
26244 PyObject * obj0 = 0 ;
26245 PyObject * obj1 = 0 ;
26246 char *kwnames[] = {
26247 (char *) "self",(char *) "other", NULL
26248 };
26249
26250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26252 if (SWIG_arg_fail(1)) SWIG_fail;
26253 {
26254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26255 if (SWIG_arg_fail(2)) SWIG_fail;
26256 if (arg2 == NULL) {
26257 SWIG_null_ref("wxDateSpan");
26258 }
26259 if (SWIG_arg_fail(2)) SWIG_fail;
26260 }
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 {
26264 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26265 result = (wxDateSpan *) &_result_ref;
26266 }
26267
26268 wxPyEndAllowThreads(__tstate);
26269 if (PyErr_Occurred()) SWIG_fail;
26270 }
26271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26279 PyObject *resultobj;
26280 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26281 wxDateSpan *result;
26282 PyObject * obj0 = 0 ;
26283 char *kwnames[] = {
26284 (char *) "self", NULL
26285 };
26286
26287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26289 if (SWIG_arg_fail(1)) SWIG_fail;
26290 {
26291 PyThreadState* __tstate = wxPyBeginAllowThreads();
26292 {
26293 wxDateSpan &_result_ref = (arg1)->operator -();
26294 result = (wxDateSpan *) &_result_ref;
26295 }
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj;
26309 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26310 int arg2 ;
26311 wxDateSpan *result;
26312 PyObject * obj0 = 0 ;
26313 PyObject * obj1 = 0 ;
26314 char *kwnames[] = {
26315 (char *) "self",(char *) "factor", NULL
26316 };
26317
26318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26320 if (SWIG_arg_fail(1)) SWIG_fail;
26321 {
26322 arg2 = (int)(SWIG_As_int(obj1));
26323 if (SWIG_arg_fail(2)) SWIG_fail;
26324 }
26325 {
26326 PyThreadState* __tstate = wxPyBeginAllowThreads();
26327 {
26328 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26329 result = (wxDateSpan *) &_result_ref;
26330 }
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26336 return resultobj;
26337 fail:
26338 return NULL;
26339 }
26340
26341
26342 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26343 PyObject *resultobj;
26344 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26345 wxDateSpan *arg2 = 0 ;
26346 wxDateSpan result;
26347 PyObject * obj0 = 0 ;
26348 PyObject * obj1 = 0 ;
26349 char *kwnames[] = {
26350 (char *) "self",(char *) "other", NULL
26351 };
26352
26353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26355 if (SWIG_arg_fail(1)) SWIG_fail;
26356 {
26357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26358 if (SWIG_arg_fail(2)) SWIG_fail;
26359 if (arg2 == NULL) {
26360 SWIG_null_ref("wxDateSpan");
26361 }
26362 if (SWIG_arg_fail(2)) SWIG_fail;
26363 }
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26367
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 {
26372 wxDateSpan * resultptr;
26373 resultptr = new wxDateSpan((wxDateSpan &)(result));
26374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26375 }
26376 return resultobj;
26377 fail:
26378 return NULL;
26379 }
26380
26381
26382 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26383 PyObject *resultobj;
26384 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26385 wxDateSpan *arg2 = 0 ;
26386 wxDateSpan result;
26387 PyObject * obj0 = 0 ;
26388 PyObject * obj1 = 0 ;
26389 char *kwnames[] = {
26390 (char *) "self",(char *) "other", NULL
26391 };
26392
26393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26395 if (SWIG_arg_fail(1)) SWIG_fail;
26396 {
26397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26398 if (SWIG_arg_fail(2)) SWIG_fail;
26399 if (arg2 == NULL) {
26400 SWIG_null_ref("wxDateSpan");
26401 }
26402 if (SWIG_arg_fail(2)) SWIG_fail;
26403 }
26404 {
26405 PyThreadState* __tstate = wxPyBeginAllowThreads();
26406 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26407
26408 wxPyEndAllowThreads(__tstate);
26409 if (PyErr_Occurred()) SWIG_fail;
26410 }
26411 {
26412 wxDateSpan * resultptr;
26413 resultptr = new wxDateSpan((wxDateSpan &)(result));
26414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26415 }
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26423 PyObject *resultobj;
26424 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26425 int arg2 ;
26426 wxDateSpan result;
26427 PyObject * obj0 = 0 ;
26428 PyObject * obj1 = 0 ;
26429 char *kwnames[] = {
26430 (char *) "self",(char *) "n", NULL
26431 };
26432
26433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26435 if (SWIG_arg_fail(1)) SWIG_fail;
26436 {
26437 arg2 = (int)(SWIG_As_int(obj1));
26438 if (SWIG_arg_fail(2)) SWIG_fail;
26439 }
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 result = wxDateSpan___mul__(arg1,arg2);
26443
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 {
26448 wxDateSpan * resultptr;
26449 resultptr = new wxDateSpan((wxDateSpan &)(result));
26450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26451 }
26452 return resultobj;
26453 fail:
26454 return NULL;
26455 }
26456
26457
26458 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26459 PyObject *resultobj;
26460 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26461 int arg2 ;
26462 wxDateSpan result;
26463 PyObject * obj0 = 0 ;
26464 PyObject * obj1 = 0 ;
26465 char *kwnames[] = {
26466 (char *) "self",(char *) "n", NULL
26467 };
26468
26469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26471 if (SWIG_arg_fail(1)) SWIG_fail;
26472 {
26473 arg2 = (int)(SWIG_As_int(obj1));
26474 if (SWIG_arg_fail(2)) SWIG_fail;
26475 }
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 result = wxDateSpan___rmul__(arg1,arg2);
26479
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 {
26484 wxDateSpan * resultptr;
26485 resultptr = new wxDateSpan((wxDateSpan &)(result));
26486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26487 }
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26495 PyObject *resultobj;
26496 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26497 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26498 bool result;
26499 PyObject * obj0 = 0 ;
26500 PyObject * obj1 = 0 ;
26501 char *kwnames[] = {
26502 (char *) "self",(char *) "other", NULL
26503 };
26504
26505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26507 if (SWIG_arg_fail(1)) SWIG_fail;
26508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26509 if (SWIG_arg_fail(2)) SWIG_fail;
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26513
26514 wxPyEndAllowThreads(__tstate);
26515 if (PyErr_Occurred()) SWIG_fail;
26516 }
26517 {
26518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26519 }
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26527 PyObject *resultobj;
26528 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26529 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26530 bool result;
26531 PyObject * obj0 = 0 ;
26532 PyObject * obj1 = 0 ;
26533 char *kwnames[] = {
26534 (char *) "self",(char *) "other", NULL
26535 };
26536
26537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26539 if (SWIG_arg_fail(1)) SWIG_fail;
26540 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26541 if (SWIG_arg_fail(2)) SWIG_fail;
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26545
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 {
26550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26551 }
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26559 PyObject *obj;
26560 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26561 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26562 Py_INCREF(obj);
26563 return Py_BuildValue((char *)"");
26564 }
26565 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26566 PyObject *resultobj;
26567 long result;
26568 char *kwnames[] = {
26569 NULL
26570 };
26571
26572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = (long)wxGetLocalTime();
26576
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 {
26581 resultobj = SWIG_From_long((long)(result));
26582 }
26583 return resultobj;
26584 fail:
26585 return NULL;
26586 }
26587
26588
26589 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26590 PyObject *resultobj;
26591 long result;
26592 char *kwnames[] = {
26593 NULL
26594 };
26595
26596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = (long)wxGetUTCTime();
26600
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 {
26605 resultobj = SWIG_From_long((long)(result));
26606 }
26607 return resultobj;
26608 fail:
26609 return NULL;
26610 }
26611
26612
26613 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26614 PyObject *resultobj;
26615 long result;
26616 char *kwnames[] = {
26617 NULL
26618 };
26619
26620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 result = (long)wxGetCurrentTime();
26624
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 {
26629 resultobj = SWIG_From_long((long)(result));
26630 }
26631 return resultobj;
26632 fail:
26633 return NULL;
26634 }
26635
26636
26637 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26638 PyObject *resultobj;
26639 wxLongLong result;
26640 char *kwnames[] = {
26641 NULL
26642 };
26643
26644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 result = wxGetLocalTimeMillis();
26648
26649 wxPyEndAllowThreads(__tstate);
26650 if (PyErr_Occurred()) SWIG_fail;
26651 }
26652 {
26653 PyObject *hi, *lo, *shifter, *shifted;
26654 hi = PyLong_FromLong( (&result)->GetHi() );
26655 lo = PyLong_FromLong( (&result)->GetLo() );
26656 shifter = PyLong_FromLong(32);
26657 shifted = PyNumber_Lshift(hi, shifter);
26658 resultobj = PyNumber_Or(shifted, lo);
26659 Py_DECREF(hi);
26660 Py_DECREF(lo);
26661 Py_DECREF(shifter);
26662 Py_DECREF(shifted);
26663 }
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 static int _wrap_DefaultDateTime_set(PyObject *) {
26671 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26672 return 1;
26673 }
26674
26675
26676 static PyObject *_wrap_DefaultDateTime_get(void) {
26677 PyObject *pyobj;
26678
26679 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26680 return pyobj;
26681 }
26682
26683
26684 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj;
26686 wxDataFormatId arg1 ;
26687 wxDataFormat *result;
26688 PyObject * obj0 = 0 ;
26689 char *kwnames[] = {
26690 (char *) "type", NULL
26691 };
26692
26693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26694 {
26695 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26696 if (SWIG_arg_fail(1)) SWIG_fail;
26697 }
26698 {
26699 PyThreadState* __tstate = wxPyBeginAllowThreads();
26700 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26701
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj;
26714 wxString *arg1 = 0 ;
26715 wxDataFormat *result;
26716 bool temp1 = false ;
26717 PyObject * obj0 = 0 ;
26718 char *kwnames[] = {
26719 (char *) "format", NULL
26720 };
26721
26722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26723 {
26724 arg1 = wxString_in_helper(obj0);
26725 if (arg1 == NULL) SWIG_fail;
26726 temp1 = true;
26727 }
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26731
26732 wxPyEndAllowThreads(__tstate);
26733 if (PyErr_Occurred()) SWIG_fail;
26734 }
26735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26736 {
26737 if (temp1)
26738 delete arg1;
26739 }
26740 return resultobj;
26741 fail:
26742 {
26743 if (temp1)
26744 delete arg1;
26745 }
26746 return NULL;
26747 }
26748
26749
26750 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26751 PyObject *resultobj;
26752 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26753 PyObject * obj0 = 0 ;
26754 char *kwnames[] = {
26755 (char *) "self", NULL
26756 };
26757
26758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26760 if (SWIG_arg_fail(1)) SWIG_fail;
26761 {
26762 PyThreadState* __tstate = wxPyBeginAllowThreads();
26763 delete arg1;
26764
26765 wxPyEndAllowThreads(__tstate);
26766 if (PyErr_Occurred()) SWIG_fail;
26767 }
26768 Py_INCREF(Py_None); resultobj = Py_None;
26769 return resultobj;
26770 fail:
26771 return NULL;
26772 }
26773
26774
26775 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26776 PyObject *resultobj;
26777 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26778 wxDataFormatId arg2 ;
26779 bool result;
26780 PyObject * obj0 = 0 ;
26781 PyObject * obj1 = 0 ;
26782
26783 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26785 if (SWIG_arg_fail(1)) SWIG_fail;
26786 {
26787 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26788 if (SWIG_arg_fail(2)) SWIG_fail;
26789 }
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 {
26798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26799 }
26800 return resultobj;
26801 fail:
26802 return NULL;
26803 }
26804
26805
26806 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26807 PyObject *resultobj;
26808 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26809 wxDataFormatId arg2 ;
26810 bool result;
26811 PyObject * obj0 = 0 ;
26812 PyObject * obj1 = 0 ;
26813
26814 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26816 if (SWIG_arg_fail(1)) SWIG_fail;
26817 {
26818 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26819 if (SWIG_arg_fail(2)) SWIG_fail;
26820 }
26821 {
26822 PyThreadState* __tstate = wxPyBeginAllowThreads();
26823 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26824
26825 wxPyEndAllowThreads(__tstate);
26826 if (PyErr_Occurred()) SWIG_fail;
26827 }
26828 {
26829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26830 }
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26838 PyObject *resultobj;
26839 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26840 wxDataFormat *arg2 = 0 ;
26841 bool result;
26842 PyObject * obj0 = 0 ;
26843 PyObject * obj1 = 0 ;
26844
26845 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26847 if (SWIG_arg_fail(1)) SWIG_fail;
26848 {
26849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26850 if (SWIG_arg_fail(2)) SWIG_fail;
26851 if (arg2 == NULL) {
26852 SWIG_null_ref("wxDataFormat");
26853 }
26854 if (SWIG_arg_fail(2)) SWIG_fail;
26855 }
26856 {
26857 PyThreadState* __tstate = wxPyBeginAllowThreads();
26858 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26859
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 {
26864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26865 }
26866 return resultobj;
26867 fail:
26868 return NULL;
26869 }
26870
26871
26872 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26873 int argc;
26874 PyObject *argv[3];
26875 int ii;
26876
26877 argc = PyObject_Length(args);
26878 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26879 argv[ii] = PyTuple_GetItem(args,ii);
26880 }
26881 if (argc == 2) {
26882 int _v;
26883 {
26884 void *ptr;
26885 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26886 _v = 0;
26887 PyErr_Clear();
26888 } else {
26889 _v = 1;
26890 }
26891 }
26892 if (_v) {
26893 {
26894 void *ptr = 0;
26895 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26896 _v = 0;
26897 PyErr_Clear();
26898 } else {
26899 _v = (ptr != 0);
26900 }
26901 }
26902 if (_v) {
26903 return _wrap_DataFormat___eq____SWIG_1(self,args);
26904 }
26905 }
26906 }
26907 if (argc == 2) {
26908 int _v;
26909 {
26910 void *ptr;
26911 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26912 _v = 0;
26913 PyErr_Clear();
26914 } else {
26915 _v = 1;
26916 }
26917 }
26918 if (_v) {
26919 _v = SWIG_Check_int(argv[1]);
26920 if (_v) {
26921 return _wrap_DataFormat___eq____SWIG_0(self,args);
26922 }
26923 }
26924 }
26925
26926 Py_INCREF(Py_NotImplemented);
26927 return Py_NotImplemented;
26928 }
26929
26930
26931 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26932 PyObject *resultobj;
26933 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26934 wxDataFormat *arg2 = 0 ;
26935 bool result;
26936 PyObject * obj0 = 0 ;
26937 PyObject * obj1 = 0 ;
26938
26939 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26941 if (SWIG_arg_fail(1)) SWIG_fail;
26942 {
26943 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26944 if (SWIG_arg_fail(2)) SWIG_fail;
26945 if (arg2 == NULL) {
26946 SWIG_null_ref("wxDataFormat");
26947 }
26948 if (SWIG_arg_fail(2)) SWIG_fail;
26949 }
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26953
26954 wxPyEndAllowThreads(__tstate);
26955 if (PyErr_Occurred()) SWIG_fail;
26956 }
26957 {
26958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26959 }
26960 return resultobj;
26961 fail:
26962 return NULL;
26963 }
26964
26965
26966 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26967 int argc;
26968 PyObject *argv[3];
26969 int ii;
26970
26971 argc = PyObject_Length(args);
26972 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26973 argv[ii] = PyTuple_GetItem(args,ii);
26974 }
26975 if (argc == 2) {
26976 int _v;
26977 {
26978 void *ptr;
26979 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26980 _v = 0;
26981 PyErr_Clear();
26982 } else {
26983 _v = 1;
26984 }
26985 }
26986 if (_v) {
26987 {
26988 void *ptr = 0;
26989 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26990 _v = 0;
26991 PyErr_Clear();
26992 } else {
26993 _v = (ptr != 0);
26994 }
26995 }
26996 if (_v) {
26997 return _wrap_DataFormat___ne____SWIG_1(self,args);
26998 }
26999 }
27000 }
27001 if (argc == 2) {
27002 int _v;
27003 {
27004 void *ptr;
27005 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27006 _v = 0;
27007 PyErr_Clear();
27008 } else {
27009 _v = 1;
27010 }
27011 }
27012 if (_v) {
27013 _v = SWIG_Check_int(argv[1]);
27014 if (_v) {
27015 return _wrap_DataFormat___ne____SWIG_0(self,args);
27016 }
27017 }
27018 }
27019
27020 Py_INCREF(Py_NotImplemented);
27021 return Py_NotImplemented;
27022 }
27023
27024
27025 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
27026 PyObject *resultobj;
27027 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27028 wxDataFormatId arg2 ;
27029 PyObject * obj0 = 0 ;
27030 PyObject * obj1 = 0 ;
27031 char *kwnames[] = {
27032 (char *) "self",(char *) "format", NULL
27033 };
27034
27035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
27036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27037 if (SWIG_arg_fail(1)) SWIG_fail;
27038 {
27039 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
27040 if (SWIG_arg_fail(2)) SWIG_fail;
27041 }
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 (arg1)->SetType((wxDataFormatId )arg2);
27045
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 Py_INCREF(Py_None); resultobj = Py_None;
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj;
27058 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27059 wxDataFormatId result;
27060 PyObject * obj0 = 0 ;
27061 char *kwnames[] = {
27062 (char *) "self", NULL
27063 };
27064
27065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
27066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27067 if (SWIG_arg_fail(1)) SWIG_fail;
27068 {
27069 PyThreadState* __tstate = wxPyBeginAllowThreads();
27070 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
27071
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 resultobj = SWIG_From_int((result));
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj;
27084 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27085 wxString result;
27086 PyObject * obj0 = 0 ;
27087 char *kwnames[] = {
27088 (char *) "self", NULL
27089 };
27090
27091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
27092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27093 if (SWIG_arg_fail(1)) SWIG_fail;
27094 {
27095 PyThreadState* __tstate = wxPyBeginAllowThreads();
27096 result = ((wxDataFormat const *)arg1)->GetId();
27097
27098 wxPyEndAllowThreads(__tstate);
27099 if (PyErr_Occurred()) SWIG_fail;
27100 }
27101 {
27102 #if wxUSE_UNICODE
27103 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27104 #else
27105 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27106 #endif
27107 }
27108 return resultobj;
27109 fail:
27110 return NULL;
27111 }
27112
27113
27114 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
27115 PyObject *resultobj;
27116 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27117 wxString *arg2 = 0 ;
27118 bool temp2 = false ;
27119 PyObject * obj0 = 0 ;
27120 PyObject * obj1 = 0 ;
27121 char *kwnames[] = {
27122 (char *) "self",(char *) "format", NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
27126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(1)) SWIG_fail;
27128 {
27129 arg2 = wxString_in_helper(obj1);
27130 if (arg2 == NULL) SWIG_fail;
27131 temp2 = true;
27132 }
27133 {
27134 PyThreadState* __tstate = wxPyBeginAllowThreads();
27135 (arg1)->SetId((wxString const &)*arg2);
27136
27137 wxPyEndAllowThreads(__tstate);
27138 if (PyErr_Occurred()) SWIG_fail;
27139 }
27140 Py_INCREF(Py_None); resultobj = Py_None;
27141 {
27142 if (temp2)
27143 delete arg2;
27144 }
27145 return resultobj;
27146 fail:
27147 {
27148 if (temp2)
27149 delete arg2;
27150 }
27151 return NULL;
27152 }
27153
27154
27155 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27156 PyObject *obj;
27157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27158 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27159 Py_INCREF(obj);
27160 return Py_BuildValue((char *)"");
27161 }
27162 static int _wrap_FormatInvalid_set(PyObject *) {
27163 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27164 return 1;
27165 }
27166
27167
27168 static PyObject *_wrap_FormatInvalid_get(void) {
27169 PyObject *pyobj;
27170
27171 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27172 return pyobj;
27173 }
27174
27175
27176 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27177 PyObject *resultobj;
27178 wxDataObject *arg1 = (wxDataObject *) 0 ;
27179 PyObject * obj0 = 0 ;
27180 char *kwnames[] = {
27181 (char *) "self", NULL
27182 };
27183
27184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27186 if (SWIG_arg_fail(1)) SWIG_fail;
27187 {
27188 PyThreadState* __tstate = wxPyBeginAllowThreads();
27189 delete arg1;
27190
27191 wxPyEndAllowThreads(__tstate);
27192 if (PyErr_Occurred()) SWIG_fail;
27193 }
27194 Py_INCREF(Py_None); resultobj = Py_None;
27195 return resultobj;
27196 fail:
27197 return NULL;
27198 }
27199
27200
27201 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27202 PyObject *resultobj;
27203 wxDataObject *arg1 = (wxDataObject *) 0 ;
27204 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27205 SwigValueWrapper<wxDataFormat > result;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self",(char *) "dir", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27214 if (SWIG_arg_fail(1)) SWIG_fail;
27215 if (obj1) {
27216 {
27217 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27218 if (SWIG_arg_fail(2)) SWIG_fail;
27219 }
27220 }
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27224
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 {
27229 wxDataFormat * resultptr;
27230 resultptr = new wxDataFormat((wxDataFormat &)(result));
27231 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27232 }
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj;
27241 wxDataObject *arg1 = (wxDataObject *) 0 ;
27242 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27243 size_t result;
27244 PyObject * obj0 = 0 ;
27245 PyObject * obj1 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self",(char *) "dir", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 if (obj1) {
27254 {
27255 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27256 if (SWIG_arg_fail(2)) SWIG_fail;
27257 }
27258 }
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27262
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 {
27267 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27268 }
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27276 PyObject *resultobj;
27277 wxDataObject *arg1 = (wxDataObject *) 0 ;
27278 wxDataFormat *arg2 = 0 ;
27279 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27280 bool result;
27281 PyObject * obj0 = 0 ;
27282 PyObject * obj1 = 0 ;
27283 PyObject * obj2 = 0 ;
27284 char *kwnames[] = {
27285 (char *) "self",(char *) "format",(char *) "dir", NULL
27286 };
27287
27288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27290 if (SWIG_arg_fail(1)) SWIG_fail;
27291 {
27292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27293 if (SWIG_arg_fail(2)) SWIG_fail;
27294 if (arg2 == NULL) {
27295 SWIG_null_ref("wxDataFormat");
27296 }
27297 if (SWIG_arg_fail(2)) SWIG_fail;
27298 }
27299 if (obj2) {
27300 {
27301 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27302 if (SWIG_arg_fail(3)) SWIG_fail;
27303 }
27304 }
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27308
27309 wxPyEndAllowThreads(__tstate);
27310 if (PyErr_Occurred()) SWIG_fail;
27311 }
27312 {
27313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27314 }
27315 return resultobj;
27316 fail:
27317 return NULL;
27318 }
27319
27320
27321 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27322 PyObject *resultobj;
27323 wxDataObject *arg1 = (wxDataObject *) 0 ;
27324 wxDataFormat *arg2 = 0 ;
27325 size_t result;
27326 PyObject * obj0 = 0 ;
27327 PyObject * obj1 = 0 ;
27328 char *kwnames[] = {
27329 (char *) "self",(char *) "format", NULL
27330 };
27331
27332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27334 if (SWIG_arg_fail(1)) SWIG_fail;
27335 {
27336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27337 if (SWIG_arg_fail(2)) SWIG_fail;
27338 if (arg2 == NULL) {
27339 SWIG_null_ref("wxDataFormat");
27340 }
27341 if (SWIG_arg_fail(2)) SWIG_fail;
27342 }
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27346
27347 wxPyEndAllowThreads(__tstate);
27348 if (PyErr_Occurred()) SWIG_fail;
27349 }
27350 {
27351 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27352 }
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27360 PyObject *resultobj;
27361 wxDataObject *arg1 = (wxDataObject *) 0 ;
27362 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27363 PyObject *result;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 char *kwnames[] = {
27367 (char *) "self",(char *) "dir", NULL
27368 };
27369
27370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27372 if (SWIG_arg_fail(1)) SWIG_fail;
27373 if (obj1) {
27374 {
27375 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27376 if (SWIG_arg_fail(2)) SWIG_fail;
27377 }
27378 }
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27382
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 resultobj = result;
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27394 PyObject *resultobj;
27395 wxDataObject *arg1 = (wxDataObject *) 0 ;
27396 wxDataFormat *arg2 = 0 ;
27397 PyObject *result;
27398 PyObject * obj0 = 0 ;
27399 PyObject * obj1 = 0 ;
27400 char *kwnames[] = {
27401 (char *) "self",(char *) "format", NULL
27402 };
27403
27404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27406 if (SWIG_arg_fail(1)) SWIG_fail;
27407 {
27408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27409 if (SWIG_arg_fail(2)) SWIG_fail;
27410 if (arg2 == NULL) {
27411 SWIG_null_ref("wxDataFormat");
27412 }
27413 if (SWIG_arg_fail(2)) SWIG_fail;
27414 }
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27418
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 resultobj = result;
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27430 PyObject *resultobj;
27431 wxDataObject *arg1 = (wxDataObject *) 0 ;
27432 wxDataFormat *arg2 = 0 ;
27433 PyObject *arg3 = (PyObject *) 0 ;
27434 bool result;
27435 PyObject * obj0 = 0 ;
27436 PyObject * obj1 = 0 ;
27437 PyObject * obj2 = 0 ;
27438 char *kwnames[] = {
27439 (char *) "self",(char *) "format",(char *) "data", NULL
27440 };
27441
27442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27444 if (SWIG_arg_fail(1)) SWIG_fail;
27445 {
27446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27447 if (SWIG_arg_fail(2)) SWIG_fail;
27448 if (arg2 == NULL) {
27449 SWIG_null_ref("wxDataFormat");
27450 }
27451 if (SWIG_arg_fail(2)) SWIG_fail;
27452 }
27453 arg3 = obj2;
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27457
27458 wxPyEndAllowThreads(__tstate);
27459 if (PyErr_Occurred()) SWIG_fail;
27460 }
27461 {
27462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27463 }
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27471 PyObject *obj;
27472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27473 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27474 Py_INCREF(obj);
27475 return Py_BuildValue((char *)"");
27476 }
27477 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27478 PyObject *resultobj;
27479 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27480 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27481 wxDataObjectSimple *result;
27482 PyObject * obj0 = 0 ;
27483 char *kwnames[] = {
27484 (char *) "format", NULL
27485 };
27486
27487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27488 if (obj0) {
27489 {
27490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27491 if (SWIG_arg_fail(1)) SWIG_fail;
27492 if (arg1 == NULL) {
27493 SWIG_null_ref("wxDataFormat");
27494 }
27495 if (SWIG_arg_fail(1)) SWIG_fail;
27496 }
27497 }
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27501
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj;
27514 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27515 wxDataFormat *result;
27516 PyObject * obj0 = 0 ;
27517 char *kwnames[] = {
27518 (char *) "self", NULL
27519 };
27520
27521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27523 if (SWIG_arg_fail(1)) SWIG_fail;
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 {
27527 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27528 result = (wxDataFormat *) &_result_ref;
27529 }
27530
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27542 PyObject *resultobj;
27543 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27544 wxDataFormat *arg2 = 0 ;
27545 PyObject * obj0 = 0 ;
27546 PyObject * obj1 = 0 ;
27547 char *kwnames[] = {
27548 (char *) "self",(char *) "format", NULL
27549 };
27550
27551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27553 if (SWIG_arg_fail(1)) SWIG_fail;
27554 {
27555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27556 if (SWIG_arg_fail(2)) SWIG_fail;
27557 if (arg2 == NULL) {
27558 SWIG_null_ref("wxDataFormat");
27559 }
27560 if (SWIG_arg_fail(2)) SWIG_fail;
27561 }
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27565
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 Py_INCREF(Py_None); resultobj = Py_None;
27570 return resultobj;
27571 fail:
27572 return NULL;
27573 }
27574
27575
27576 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27577 PyObject *resultobj;
27578 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27579 size_t result;
27580 PyObject * obj0 = 0 ;
27581 char *kwnames[] = {
27582 (char *) "self", NULL
27583 };
27584
27585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27587 if (SWIG_arg_fail(1)) SWIG_fail;
27588 {
27589 PyThreadState* __tstate = wxPyBeginAllowThreads();
27590 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27591
27592 wxPyEndAllowThreads(__tstate);
27593 if (PyErr_Occurred()) SWIG_fail;
27594 }
27595 {
27596 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27597 }
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj;
27606 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27607 PyObject *result;
27608 PyObject * obj0 = 0 ;
27609 char *kwnames[] = {
27610 (char *) "self", NULL
27611 };
27612
27613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27615 if (SWIG_arg_fail(1)) SWIG_fail;
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 resultobj = result;
27624 return resultobj;
27625 fail:
27626 return NULL;
27627 }
27628
27629
27630 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj;
27632 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27633 PyObject *arg2 = (PyObject *) 0 ;
27634 bool result;
27635 PyObject * obj0 = 0 ;
27636 PyObject * obj1 = 0 ;
27637 char *kwnames[] = {
27638 (char *) "self",(char *) "data", NULL
27639 };
27640
27641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(1)) SWIG_fail;
27644 arg2 = obj1;
27645 {
27646 PyThreadState* __tstate = wxPyBeginAllowThreads();
27647 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27648
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 {
27653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27654 }
27655 return resultobj;
27656 fail:
27657 return NULL;
27658 }
27659
27660
27661 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27662 PyObject *obj;
27663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27664 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27665 Py_INCREF(obj);
27666 return Py_BuildValue((char *)"");
27667 }
27668 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27669 PyObject *resultobj;
27670 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27671 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27672 wxPyDataObjectSimple *result;
27673 PyObject * obj0 = 0 ;
27674 char *kwnames[] = {
27675 (char *) "format", NULL
27676 };
27677
27678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27679 if (obj0) {
27680 {
27681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27682 if (SWIG_arg_fail(1)) SWIG_fail;
27683 if (arg1 == NULL) {
27684 SWIG_null_ref("wxDataFormat");
27685 }
27686 if (SWIG_arg_fail(1)) SWIG_fail;
27687 }
27688 }
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27692
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj;
27705 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27706 PyObject *arg2 = (PyObject *) 0 ;
27707 PyObject *arg3 = (PyObject *) 0 ;
27708 PyObject * obj0 = 0 ;
27709 PyObject * obj1 = 0 ;
27710 PyObject * obj2 = 0 ;
27711 char *kwnames[] = {
27712 (char *) "self",(char *) "self",(char *) "_class", NULL
27713 };
27714
27715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27717 if (SWIG_arg_fail(1)) SWIG_fail;
27718 arg2 = obj1;
27719 arg3 = obj2;
27720 {
27721 PyThreadState* __tstate = wxPyBeginAllowThreads();
27722 (arg1)->_setCallbackInfo(arg2,arg3);
27723
27724 wxPyEndAllowThreads(__tstate);
27725 if (PyErr_Occurred()) SWIG_fail;
27726 }
27727 Py_INCREF(Py_None); resultobj = Py_None;
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27735 PyObject *obj;
27736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27737 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27738 Py_INCREF(obj);
27739 return Py_BuildValue((char *)"");
27740 }
27741 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27742 PyObject *resultobj;
27743 wxDataObjectComposite *result;
27744 char *kwnames[] = {
27745 NULL
27746 };
27747
27748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27752
27753 wxPyEndAllowThreads(__tstate);
27754 if (PyErr_Occurred()) SWIG_fail;
27755 }
27756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27764 PyObject *resultobj;
27765 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27766 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27767 bool arg3 = (bool) false ;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 PyObject * obj2 = 0 ;
27771 char *kwnames[] = {
27772 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27773 };
27774
27775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27777 if (SWIG_arg_fail(1)) SWIG_fail;
27778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27779 if (SWIG_arg_fail(2)) SWIG_fail;
27780 if (obj2) {
27781 {
27782 arg3 = (bool)(SWIG_As_bool(obj2));
27783 if (SWIG_arg_fail(3)) SWIG_fail;
27784 }
27785 }
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 (arg1)->Add(arg2,arg3);
27789
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 Py_INCREF(Py_None); resultobj = Py_None;
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27801 PyObject *obj;
27802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27803 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27804 Py_INCREF(obj);
27805 return Py_BuildValue((char *)"");
27806 }
27807 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27808 PyObject *resultobj;
27809 wxString const &arg1_defvalue = wxPyEmptyString ;
27810 wxString *arg1 = (wxString *) &arg1_defvalue ;
27811 wxTextDataObject *result;
27812 bool temp1 = false ;
27813 PyObject * obj0 = 0 ;
27814 char *kwnames[] = {
27815 (char *) "text", NULL
27816 };
27817
27818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27819 if (obj0) {
27820 {
27821 arg1 = wxString_in_helper(obj0);
27822 if (arg1 == NULL) SWIG_fail;
27823 temp1 = true;
27824 }
27825 }
27826 {
27827 PyThreadState* __tstate = wxPyBeginAllowThreads();
27828 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27829
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27834 {
27835 if (temp1)
27836 delete arg1;
27837 }
27838 return resultobj;
27839 fail:
27840 {
27841 if (temp1)
27842 delete arg1;
27843 }
27844 return NULL;
27845 }
27846
27847
27848 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27849 PyObject *resultobj;
27850 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27851 size_t result;
27852 PyObject * obj0 = 0 ;
27853 char *kwnames[] = {
27854 (char *) "self", NULL
27855 };
27856
27857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27859 if (SWIG_arg_fail(1)) SWIG_fail;
27860 {
27861 PyThreadState* __tstate = wxPyBeginAllowThreads();
27862 result = (size_t)(arg1)->GetTextLength();
27863
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27869 }
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27877 PyObject *resultobj;
27878 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27879 wxString result;
27880 PyObject * obj0 = 0 ;
27881 char *kwnames[] = {
27882 (char *) "self", NULL
27883 };
27884
27885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27887 if (SWIG_arg_fail(1)) SWIG_fail;
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 result = (arg1)->GetText();
27891
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 {
27896 #if wxUSE_UNICODE
27897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27898 #else
27899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27900 #endif
27901 }
27902 return resultobj;
27903 fail:
27904 return NULL;
27905 }
27906
27907
27908 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27909 PyObject *resultobj;
27910 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27911 wxString *arg2 = 0 ;
27912 bool temp2 = false ;
27913 PyObject * obj0 = 0 ;
27914 PyObject * obj1 = 0 ;
27915 char *kwnames[] = {
27916 (char *) "self",(char *) "text", NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 {
27923 arg2 = wxString_in_helper(obj1);
27924 if (arg2 == NULL) SWIG_fail;
27925 temp2 = true;
27926 }
27927 {
27928 PyThreadState* __tstate = wxPyBeginAllowThreads();
27929 (arg1)->SetText((wxString const &)*arg2);
27930
27931 wxPyEndAllowThreads(__tstate);
27932 if (PyErr_Occurred()) SWIG_fail;
27933 }
27934 Py_INCREF(Py_None); resultobj = Py_None;
27935 {
27936 if (temp2)
27937 delete arg2;
27938 }
27939 return resultobj;
27940 fail:
27941 {
27942 if (temp2)
27943 delete arg2;
27944 }
27945 return NULL;
27946 }
27947
27948
27949 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27950 PyObject *obj;
27951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27952 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27953 Py_INCREF(obj);
27954 return Py_BuildValue((char *)"");
27955 }
27956 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27957 PyObject *resultobj;
27958 wxString const &arg1_defvalue = wxPyEmptyString ;
27959 wxString *arg1 = (wxString *) &arg1_defvalue ;
27960 wxPyTextDataObject *result;
27961 bool temp1 = false ;
27962 PyObject * obj0 = 0 ;
27963 char *kwnames[] = {
27964 (char *) "text", NULL
27965 };
27966
27967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27968 if (obj0) {
27969 {
27970 arg1 = wxString_in_helper(obj0);
27971 if (arg1 == NULL) SWIG_fail;
27972 temp1 = true;
27973 }
27974 }
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27978
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27983 {
27984 if (temp1)
27985 delete arg1;
27986 }
27987 return resultobj;
27988 fail:
27989 {
27990 if (temp1)
27991 delete arg1;
27992 }
27993 return NULL;
27994 }
27995
27996
27997 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj;
27999 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
28000 PyObject *arg2 = (PyObject *) 0 ;
28001 PyObject *arg3 = (PyObject *) 0 ;
28002 PyObject * obj0 = 0 ;
28003 PyObject * obj1 = 0 ;
28004 PyObject * obj2 = 0 ;
28005 char *kwnames[] = {
28006 (char *) "self",(char *) "self",(char *) "_class", NULL
28007 };
28008
28009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(1)) SWIG_fail;
28012 arg2 = obj1;
28013 arg3 = obj2;
28014 {
28015 PyThreadState* __tstate = wxPyBeginAllowThreads();
28016 (arg1)->_setCallbackInfo(arg2,arg3);
28017
28018 wxPyEndAllowThreads(__tstate);
28019 if (PyErr_Occurred()) SWIG_fail;
28020 }
28021 Py_INCREF(Py_None); resultobj = Py_None;
28022 return resultobj;
28023 fail:
28024 return NULL;
28025 }
28026
28027
28028 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
28029 PyObject *obj;
28030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28031 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
28032 Py_INCREF(obj);
28033 return Py_BuildValue((char *)"");
28034 }
28035 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj;
28037 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28038 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28039 wxBitmapDataObject *result;
28040 PyObject * obj0 = 0 ;
28041 char *kwnames[] = {
28042 (char *) "bitmap", NULL
28043 };
28044
28045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
28046 if (obj0) {
28047 {
28048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28049 if (SWIG_arg_fail(1)) SWIG_fail;
28050 if (arg1 == NULL) {
28051 SWIG_null_ref("wxBitmap");
28052 }
28053 if (SWIG_arg_fail(1)) SWIG_fail;
28054 }
28055 }
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
28059
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
28064 return resultobj;
28065 fail:
28066 return NULL;
28067 }
28068
28069
28070 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28071 PyObject *resultobj;
28072 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28073 wxBitmap result;
28074 PyObject * obj0 = 0 ;
28075 char *kwnames[] = {
28076 (char *) "self", NULL
28077 };
28078
28079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
28080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28081 if (SWIG_arg_fail(1)) SWIG_fail;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
28085
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 {
28090 wxBitmap * resultptr;
28091 resultptr = new wxBitmap((wxBitmap &)(result));
28092 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
28093 }
28094 return resultobj;
28095 fail:
28096 return NULL;
28097 }
28098
28099
28100 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
28101 PyObject *resultobj;
28102 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
28103 wxBitmap *arg2 = 0 ;
28104 PyObject * obj0 = 0 ;
28105 PyObject * obj1 = 0 ;
28106 char *kwnames[] = {
28107 (char *) "self",(char *) "bitmap", NULL
28108 };
28109
28110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
28111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28112 if (SWIG_arg_fail(1)) SWIG_fail;
28113 {
28114 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(2)) SWIG_fail;
28116 if (arg2 == NULL) {
28117 SWIG_null_ref("wxBitmap");
28118 }
28119 if (SWIG_arg_fail(2)) SWIG_fail;
28120 }
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 (arg1)->SetBitmap((wxBitmap const &)*arg2);
28124
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 Py_INCREF(Py_None); resultobj = Py_None;
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
28136 PyObject *obj;
28137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28138 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28139 Py_INCREF(obj);
28140 return Py_BuildValue((char *)"");
28141 }
28142 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj;
28144 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28145 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28146 wxPyBitmapDataObject *result;
28147 PyObject * obj0 = 0 ;
28148 char *kwnames[] = {
28149 (char *) "bitmap", NULL
28150 };
28151
28152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28153 if (obj0) {
28154 {
28155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28156 if (SWIG_arg_fail(1)) SWIG_fail;
28157 if (arg1 == NULL) {
28158 SWIG_null_ref("wxBitmap");
28159 }
28160 if (SWIG_arg_fail(1)) SWIG_fail;
28161 }
28162 }
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28166
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj;
28179 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28180 PyObject *arg2 = (PyObject *) 0 ;
28181 PyObject *arg3 = (PyObject *) 0 ;
28182 PyObject * obj0 = 0 ;
28183 PyObject * obj1 = 0 ;
28184 PyObject * obj2 = 0 ;
28185 char *kwnames[] = {
28186 (char *) "self",(char *) "self",(char *) "_class", NULL
28187 };
28188
28189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 arg2 = obj1;
28193 arg3 = obj2;
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 (arg1)->_setCallbackInfo(arg2,arg3);
28197
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 Py_INCREF(Py_None); resultobj = Py_None;
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28209 PyObject *obj;
28210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28211 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28212 Py_INCREF(obj);
28213 return Py_BuildValue((char *)"");
28214 }
28215 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28216 PyObject *resultobj;
28217 wxFileDataObject *result;
28218 char *kwnames[] = {
28219 NULL
28220 };
28221
28222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28223 {
28224 PyThreadState* __tstate = wxPyBeginAllowThreads();
28225 result = (wxFileDataObject *)new wxFileDataObject();
28226
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28238 PyObject *resultobj;
28239 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28240 wxArrayString *result;
28241 PyObject * obj0 = 0 ;
28242 char *kwnames[] = {
28243 (char *) "self", NULL
28244 };
28245
28246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28248 if (SWIG_arg_fail(1)) SWIG_fail;
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 {
28252 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28253 result = (wxArrayString *) &_result_ref;
28254 }
28255
28256 wxPyEndAllowThreads(__tstate);
28257 if (PyErr_Occurred()) SWIG_fail;
28258 }
28259 {
28260 resultobj = wxArrayString2PyList_helper(*result);
28261 }
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj;
28270 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28271 wxString *arg2 = 0 ;
28272 bool temp2 = false ;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char *kwnames[] = {
28276 (char *) "self",(char *) "filename", NULL
28277 };
28278
28279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(1)) SWIG_fail;
28282 {
28283 arg2 = wxString_in_helper(obj1);
28284 if (arg2 == NULL) SWIG_fail;
28285 temp2 = true;
28286 }
28287 {
28288 PyThreadState* __tstate = wxPyBeginAllowThreads();
28289 (arg1)->AddFile((wxString const &)*arg2);
28290
28291 wxPyEndAllowThreads(__tstate);
28292 if (PyErr_Occurred()) SWIG_fail;
28293 }
28294 Py_INCREF(Py_None); resultobj = Py_None;
28295 {
28296 if (temp2)
28297 delete arg2;
28298 }
28299 return resultobj;
28300 fail:
28301 {
28302 if (temp2)
28303 delete arg2;
28304 }
28305 return NULL;
28306 }
28307
28308
28309 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28310 PyObject *obj;
28311 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28312 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28313 Py_INCREF(obj);
28314 return Py_BuildValue((char *)"");
28315 }
28316 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28317 PyObject *resultobj;
28318 wxDataFormat *arg1 = 0 ;
28319 wxCustomDataObject *result;
28320 PyObject * obj0 = 0 ;
28321
28322 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28323 {
28324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28325 if (SWIG_arg_fail(1)) SWIG_fail;
28326 if (arg1 == NULL) {
28327 SWIG_null_ref("wxDataFormat");
28328 }
28329 if (SWIG_arg_fail(1)) SWIG_fail;
28330 }
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28334
28335 wxPyEndAllowThreads(__tstate);
28336 if (PyErr_Occurred()) SWIG_fail;
28337 }
28338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28339 return resultobj;
28340 fail:
28341 return NULL;
28342 }
28343
28344
28345 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28346 PyObject *resultobj;
28347 wxString *arg1 = 0 ;
28348 wxCustomDataObject *result;
28349 bool temp1 = false ;
28350 PyObject * obj0 = 0 ;
28351
28352 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28353 {
28354 arg1 = wxString_in_helper(obj0);
28355 if (arg1 == NULL) SWIG_fail;
28356 temp1 = true;
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28361
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28366 {
28367 if (temp1)
28368 delete arg1;
28369 }
28370 return resultobj;
28371 fail:
28372 {
28373 if (temp1)
28374 delete arg1;
28375 }
28376 return NULL;
28377 }
28378
28379
28380 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28381 PyObject *resultobj;
28382 wxCustomDataObject *result;
28383
28384 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (wxCustomDataObject *)new wxCustomDataObject();
28388
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28393 return resultobj;
28394 fail:
28395 return NULL;
28396 }
28397
28398
28399 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28400 int argc;
28401 PyObject *argv[2];
28402 int ii;
28403
28404 argc = PyObject_Length(args);
28405 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28406 argv[ii] = PyTuple_GetItem(args,ii);
28407 }
28408 if (argc == 0) {
28409 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28410 }
28411 if (argc == 1) {
28412 int _v;
28413 {
28414 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28415 }
28416 if (_v) {
28417 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28418 }
28419 }
28420 if (argc == 1) {
28421 int _v;
28422 {
28423 void *ptr = 0;
28424 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28425 _v = 0;
28426 PyErr_Clear();
28427 } else {
28428 _v = (ptr != 0);
28429 }
28430 }
28431 if (_v) {
28432 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28433 }
28434 }
28435
28436 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28437 return NULL;
28438 }
28439
28440
28441 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28442 PyObject *resultobj;
28443 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28444 PyObject *arg2 = (PyObject *) 0 ;
28445 bool result;
28446 PyObject * obj0 = 0 ;
28447 PyObject * obj1 = 0 ;
28448 char *kwnames[] = {
28449 (char *) "self",(char *) "data", NULL
28450 };
28451
28452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28454 if (SWIG_arg_fail(1)) SWIG_fail;
28455 arg2 = obj1;
28456 {
28457 PyThreadState* __tstate = wxPyBeginAllowThreads();
28458 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28459
28460 wxPyEndAllowThreads(__tstate);
28461 if (PyErr_Occurred()) SWIG_fail;
28462 }
28463 {
28464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28465 }
28466 return resultobj;
28467 fail:
28468 return NULL;
28469 }
28470
28471
28472 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28473 PyObject *resultobj;
28474 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28475 size_t result;
28476 PyObject * obj0 = 0 ;
28477 char *kwnames[] = {
28478 (char *) "self", NULL
28479 };
28480
28481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28483 if (SWIG_arg_fail(1)) SWIG_fail;
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (size_t)(arg1)->GetSize();
28487
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 {
28492 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28493 }
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28501 PyObject *resultobj;
28502 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28503 PyObject *result;
28504 PyObject * obj0 = 0 ;
28505 char *kwnames[] = {
28506 (char *) "self", NULL
28507 };
28508
28509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28511 if (SWIG_arg_fail(1)) SWIG_fail;
28512 {
28513 PyThreadState* __tstate = wxPyBeginAllowThreads();
28514 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28515
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 resultobj = result;
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28527 PyObject *obj;
28528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28529 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28530 Py_INCREF(obj);
28531 return Py_BuildValue((char *)"");
28532 }
28533 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28534 PyObject *resultobj;
28535 wxURLDataObject *result;
28536 char *kwnames[] = {
28537 NULL
28538 };
28539
28540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (wxURLDataObject *)new wxURLDataObject();
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28556 PyObject *resultobj;
28557 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28558 wxString result;
28559 PyObject * obj0 = 0 ;
28560 char *kwnames[] = {
28561 (char *) "self", NULL
28562 };
28563
28564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28566 if (SWIG_arg_fail(1)) SWIG_fail;
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 result = (arg1)->GetURL();
28570
28571 wxPyEndAllowThreads(__tstate);
28572 if (PyErr_Occurred()) SWIG_fail;
28573 }
28574 {
28575 #if wxUSE_UNICODE
28576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28577 #else
28578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28579 #endif
28580 }
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj;
28589 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28590 wxString *arg2 = 0 ;
28591 bool temp2 = false ;
28592 PyObject * obj0 = 0 ;
28593 PyObject * obj1 = 0 ;
28594 char *kwnames[] = {
28595 (char *) "self",(char *) "url", NULL
28596 };
28597
28598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28600 if (SWIG_arg_fail(1)) SWIG_fail;
28601 {
28602 arg2 = wxString_in_helper(obj1);
28603 if (arg2 == NULL) SWIG_fail;
28604 temp2 = true;
28605 }
28606 {
28607 PyThreadState* __tstate = wxPyBeginAllowThreads();
28608 (arg1)->SetURL((wxString const &)*arg2);
28609
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 Py_INCREF(Py_None); resultobj = Py_None;
28614 {
28615 if (temp2)
28616 delete arg2;
28617 }
28618 return resultobj;
28619 fail:
28620 {
28621 if (temp2)
28622 delete arg2;
28623 }
28624 return NULL;
28625 }
28626
28627
28628 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28629 PyObject *obj;
28630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28631 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28632 Py_INCREF(obj);
28633 return Py_BuildValue((char *)"");
28634 }
28635 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28636 PyObject *resultobj;
28637 wxMetafileDataObject *result;
28638 char *kwnames[] = {
28639 NULL
28640 };
28641
28642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28646
28647 wxPyEndAllowThreads(__tstate);
28648 if (PyErr_Occurred()) SWIG_fail;
28649 }
28650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28651 return resultobj;
28652 fail:
28653 return NULL;
28654 }
28655
28656
28657 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28658 PyObject *resultobj;
28659 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28660 wxMetafile *arg2 = 0 ;
28661 PyObject * obj0 = 0 ;
28662 PyObject * obj1 = 0 ;
28663 char *kwnames[] = {
28664 (char *) "self",(char *) "metafile", NULL
28665 };
28666
28667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28669 if (SWIG_arg_fail(1)) SWIG_fail;
28670 {
28671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28672 if (SWIG_arg_fail(2)) SWIG_fail;
28673 if (arg2 == NULL) {
28674 SWIG_null_ref("wxMetafile");
28675 }
28676 if (SWIG_arg_fail(2)) SWIG_fail;
28677 }
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28681
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 Py_INCREF(Py_None); resultobj = Py_None;
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28693 PyObject *resultobj;
28694 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28695 wxMetafile result;
28696 PyObject * obj0 = 0 ;
28697 char *kwnames[] = {
28698 (char *) "self", NULL
28699 };
28700
28701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(1)) SWIG_fail;
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28707
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 {
28712 wxMetafile * resultptr;
28713 resultptr = new wxMetafile((wxMetafile &)(result));
28714 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28715 }
28716 return resultobj;
28717 fail:
28718 return NULL;
28719 }
28720
28721
28722 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28723 PyObject *obj;
28724 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28725 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28726 Py_INCREF(obj);
28727 return Py_BuildValue((char *)"");
28728 }
28729 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxDragResult arg1 ;
28732 bool result;
28733 PyObject * obj0 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "res", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28739 {
28740 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28741 if (SWIG_arg_fail(1)) SWIG_fail;
28742 }
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28746
28747 wxPyEndAllowThreads(__tstate);
28748 if (PyErr_Occurred()) SWIG_fail;
28749 }
28750 {
28751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28752 }
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28760 PyObject *resultobj;
28761 wxWindow *arg1 = (wxWindow *) 0 ;
28762 wxCursor const &arg2_defvalue = wxNullCursor ;
28763 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28764 wxCursor const &arg3_defvalue = wxNullCursor ;
28765 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28766 wxCursor const &arg4_defvalue = wxNullCursor ;
28767 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28768 wxPyDropSource *result;
28769 PyObject * obj0 = 0 ;
28770 PyObject * obj1 = 0 ;
28771 PyObject * obj2 = 0 ;
28772 PyObject * obj3 = 0 ;
28773 char *kwnames[] = {
28774 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28775 };
28776
28777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28779 if (SWIG_arg_fail(1)) SWIG_fail;
28780 if (obj1) {
28781 {
28782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28783 if (SWIG_arg_fail(2)) SWIG_fail;
28784 if (arg2 == NULL) {
28785 SWIG_null_ref("wxCursor");
28786 }
28787 if (SWIG_arg_fail(2)) SWIG_fail;
28788 }
28789 }
28790 if (obj2) {
28791 {
28792 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28793 if (SWIG_arg_fail(3)) SWIG_fail;
28794 if (arg3 == NULL) {
28795 SWIG_null_ref("wxCursor");
28796 }
28797 if (SWIG_arg_fail(3)) SWIG_fail;
28798 }
28799 }
28800 if (obj3) {
28801 {
28802 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(4)) SWIG_fail;
28804 if (arg4 == NULL) {
28805 SWIG_null_ref("wxCursor");
28806 }
28807 if (SWIG_arg_fail(4)) SWIG_fail;
28808 }
28809 }
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28813
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28825 PyObject *resultobj;
28826 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28827 PyObject *arg2 = (PyObject *) 0 ;
28828 PyObject *arg3 = (PyObject *) 0 ;
28829 int arg4 ;
28830 PyObject * obj0 = 0 ;
28831 PyObject * obj1 = 0 ;
28832 PyObject * obj2 = 0 ;
28833 PyObject * obj3 = 0 ;
28834 char *kwnames[] = {
28835 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28836 };
28837
28838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28840 if (SWIG_arg_fail(1)) SWIG_fail;
28841 arg2 = obj1;
28842 arg3 = obj2;
28843 {
28844 arg4 = (int)(SWIG_As_int(obj3));
28845 if (SWIG_arg_fail(4)) SWIG_fail;
28846 }
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28850
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 Py_INCREF(Py_None); resultobj = Py_None;
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj;
28863 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28864 PyObject * obj0 = 0 ;
28865 char *kwnames[] = {
28866 (char *) "self", NULL
28867 };
28868
28869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28871 if (SWIG_arg_fail(1)) SWIG_fail;
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 delete arg1;
28875
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 Py_INCREF(Py_None); resultobj = Py_None;
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj;
28888 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28889 wxDataObject *arg2 = 0 ;
28890 PyObject * obj0 = 0 ;
28891 PyObject * obj1 = 0 ;
28892 char *kwnames[] = {
28893 (char *) "self",(char *) "data", NULL
28894 };
28895
28896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28898 if (SWIG_arg_fail(1)) SWIG_fail;
28899 {
28900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28901 if (SWIG_arg_fail(2)) SWIG_fail;
28902 if (arg2 == NULL) {
28903 SWIG_null_ref("wxDataObject");
28904 }
28905 if (SWIG_arg_fail(2)) SWIG_fail;
28906 }
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 (arg1)->SetData(*arg2);
28910
28911 wxPyEndAllowThreads(__tstate);
28912 if (PyErr_Occurred()) SWIG_fail;
28913 }
28914 Py_INCREF(Py_None); resultobj = Py_None;
28915 return resultobj;
28916 fail:
28917 return NULL;
28918 }
28919
28920
28921 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28922 PyObject *resultobj;
28923 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28924 wxDataObject *result;
28925 PyObject * obj0 = 0 ;
28926 char *kwnames[] = {
28927 (char *) "self", NULL
28928 };
28929
28930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28932 if (SWIG_arg_fail(1)) SWIG_fail;
28933 {
28934 PyThreadState* __tstate = wxPyBeginAllowThreads();
28935 result = (wxDataObject *)(arg1)->GetDataObject();
28936
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28948 PyObject *resultobj;
28949 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28950 wxDragResult arg2 ;
28951 wxCursor *arg3 = 0 ;
28952 PyObject * obj0 = 0 ;
28953 PyObject * obj1 = 0 ;
28954 PyObject * obj2 = 0 ;
28955 char *kwnames[] = {
28956 (char *) "self",(char *) "res",(char *) "cursor", NULL
28957 };
28958
28959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28961 if (SWIG_arg_fail(1)) SWIG_fail;
28962 {
28963 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28964 if (SWIG_arg_fail(2)) SWIG_fail;
28965 }
28966 {
28967 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28968 if (SWIG_arg_fail(3)) SWIG_fail;
28969 if (arg3 == NULL) {
28970 SWIG_null_ref("wxCursor");
28971 }
28972 if (SWIG_arg_fail(3)) SWIG_fail;
28973 }
28974 {
28975 PyThreadState* __tstate = wxPyBeginAllowThreads();
28976 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28977
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 Py_INCREF(Py_None); resultobj = Py_None;
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj;
28990 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28991 int arg2 = (int) wxDrag_CopyOnly ;
28992 wxDragResult result;
28993 PyObject * obj0 = 0 ;
28994 PyObject * obj1 = 0 ;
28995 char *kwnames[] = {
28996 (char *) "self",(char *) "flags", NULL
28997 };
28998
28999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
29000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29001 if (SWIG_arg_fail(1)) SWIG_fail;
29002 if (obj1) {
29003 {
29004 arg2 = (int)(SWIG_As_int(obj1));
29005 if (SWIG_arg_fail(2)) SWIG_fail;
29006 }
29007 }
29008 {
29009 PyThreadState* __tstate = wxPyBeginAllowThreads();
29010 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
29011
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 resultobj = SWIG_From_int((result));
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
29023 PyObject *resultobj;
29024 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29025 wxDragResult arg2 ;
29026 bool result;
29027 PyObject * obj0 = 0 ;
29028 PyObject * obj1 = 0 ;
29029 char *kwnames[] = {
29030 (char *) "self",(char *) "effect", NULL
29031 };
29032
29033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
29034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29035 if (SWIG_arg_fail(1)) SWIG_fail;
29036 {
29037 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29038 if (SWIG_arg_fail(2)) SWIG_fail;
29039 }
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
29043
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 {
29048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29049 }
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
29057 PyObject *obj;
29058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29059 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
29060 Py_INCREF(obj);
29061 return Py_BuildValue((char *)"");
29062 }
29063 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29064 PyObject *resultobj;
29065 wxDataObject *arg1 = (wxDataObject *) NULL ;
29066 wxPyDropTarget *result;
29067 PyObject * obj0 = 0 ;
29068 char *kwnames[] = {
29069 (char *) "dataObject", NULL
29070 };
29071
29072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
29073 if (obj0) {
29074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29075 if (SWIG_arg_fail(1)) SWIG_fail;
29076 }
29077 {
29078 PyThreadState* __tstate = wxPyBeginAllowThreads();
29079 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
29080
29081 wxPyEndAllowThreads(__tstate);
29082 if (PyErr_Occurred()) SWIG_fail;
29083 }
29084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
29085 return resultobj;
29086 fail:
29087 return NULL;
29088 }
29089
29090
29091 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29092 PyObject *resultobj;
29093 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29094 PyObject *arg2 = (PyObject *) 0 ;
29095 PyObject *arg3 = (PyObject *) 0 ;
29096 PyObject * obj0 = 0 ;
29097 PyObject * obj1 = 0 ;
29098 PyObject * obj2 = 0 ;
29099 char *kwnames[] = {
29100 (char *) "self",(char *) "self",(char *) "_class", NULL
29101 };
29102
29103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29105 if (SWIG_arg_fail(1)) SWIG_fail;
29106 arg2 = obj1;
29107 arg3 = obj2;
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 (arg1)->_setCallbackInfo(arg2,arg3);
29111
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 Py_INCREF(Py_None); resultobj = Py_None;
29116 return resultobj;
29117 fail:
29118 return NULL;
29119 }
29120
29121
29122 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29123 PyObject *resultobj;
29124 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29125 PyObject * obj0 = 0 ;
29126 char *kwnames[] = {
29127 (char *) "self", NULL
29128 };
29129
29130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
29131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29132 if (SWIG_arg_fail(1)) SWIG_fail;
29133 {
29134 PyThreadState* __tstate = wxPyBeginAllowThreads();
29135 delete arg1;
29136
29137 wxPyEndAllowThreads(__tstate);
29138 if (PyErr_Occurred()) SWIG_fail;
29139 }
29140 Py_INCREF(Py_None); resultobj = Py_None;
29141 return resultobj;
29142 fail:
29143 return NULL;
29144 }
29145
29146
29147 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj;
29149 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29150 wxDataObject *result;
29151 PyObject * obj0 = 0 ;
29152 char *kwnames[] = {
29153 (char *) "self", NULL
29154 };
29155
29156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
29157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29158 if (SWIG_arg_fail(1)) SWIG_fail;
29159 {
29160 PyThreadState* __tstate = wxPyBeginAllowThreads();
29161 result = (wxDataObject *)(arg1)->GetDataObject();
29162
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj;
29175 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29176 wxDataObject *arg2 = (wxDataObject *) 0 ;
29177 PyObject * obj0 = 0 ;
29178 PyObject * obj1 = 0 ;
29179 char *kwnames[] = {
29180 (char *) "self",(char *) "dataObject", NULL
29181 };
29182
29183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
29184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29185 if (SWIG_arg_fail(1)) SWIG_fail;
29186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29187 if (SWIG_arg_fail(2)) SWIG_fail;
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 (arg1)->SetDataObject(arg2);
29191
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 Py_INCREF(Py_None); resultobj = Py_None;
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29203 PyObject *resultobj;
29204 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29205 int arg2 ;
29206 int arg3 ;
29207 wxDragResult arg4 ;
29208 wxDragResult result;
29209 PyObject * obj0 = 0 ;
29210 PyObject * obj1 = 0 ;
29211 PyObject * obj2 = 0 ;
29212 PyObject * obj3 = 0 ;
29213 char *kwnames[] = {
29214 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29215 };
29216
29217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29219 if (SWIG_arg_fail(1)) SWIG_fail;
29220 {
29221 arg2 = (int)(SWIG_As_int(obj1));
29222 if (SWIG_arg_fail(2)) SWIG_fail;
29223 }
29224 {
29225 arg3 = (int)(SWIG_As_int(obj2));
29226 if (SWIG_arg_fail(3)) SWIG_fail;
29227 }
29228 {
29229 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29230 if (SWIG_arg_fail(4)) SWIG_fail;
29231 }
29232 {
29233 PyThreadState* __tstate = wxPyBeginAllowThreads();
29234 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29235
29236 wxPyEndAllowThreads(__tstate);
29237 if (PyErr_Occurred()) SWIG_fail;
29238 }
29239 resultobj = SWIG_From_int((result));
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29247 PyObject *resultobj;
29248 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29249 int arg2 ;
29250 int arg3 ;
29251 wxDragResult arg4 ;
29252 wxDragResult result;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 PyObject * obj2 = 0 ;
29256 PyObject * obj3 = 0 ;
29257 char *kwnames[] = {
29258 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29259 };
29260
29261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29263 if (SWIG_arg_fail(1)) SWIG_fail;
29264 {
29265 arg2 = (int)(SWIG_As_int(obj1));
29266 if (SWIG_arg_fail(2)) SWIG_fail;
29267 }
29268 {
29269 arg3 = (int)(SWIG_As_int(obj2));
29270 if (SWIG_arg_fail(3)) SWIG_fail;
29271 }
29272 {
29273 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29274 if (SWIG_arg_fail(4)) SWIG_fail;
29275 }
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 resultobj = SWIG_From_int((result));
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj;
29292 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29293 PyObject * obj0 = 0 ;
29294 char *kwnames[] = {
29295 (char *) "self", NULL
29296 };
29297
29298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29300 if (SWIG_arg_fail(1)) SWIG_fail;
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 (arg1)->base_OnLeave();
29304
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 Py_INCREF(Py_None); resultobj = Py_None;
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj;
29317 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29318 int arg2 ;
29319 int arg3 ;
29320 bool result;
29321 PyObject * obj0 = 0 ;
29322 PyObject * obj1 = 0 ;
29323 PyObject * obj2 = 0 ;
29324 char *kwnames[] = {
29325 (char *) "self",(char *) "x",(char *) "y", NULL
29326 };
29327
29328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29330 if (SWIG_arg_fail(1)) SWIG_fail;
29331 {
29332 arg2 = (int)(SWIG_As_int(obj1));
29333 if (SWIG_arg_fail(2)) SWIG_fail;
29334 }
29335 {
29336 arg3 = (int)(SWIG_As_int(obj2));
29337 if (SWIG_arg_fail(3)) SWIG_fail;
29338 }
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29342
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 {
29347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29348 }
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj;
29357 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29358 bool result;
29359 PyObject * obj0 = 0 ;
29360 char *kwnames[] = {
29361 (char *) "self", NULL
29362 };
29363
29364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29366 if (SWIG_arg_fail(1)) SWIG_fail;
29367 {
29368 PyThreadState* __tstate = wxPyBeginAllowThreads();
29369 result = (bool)(arg1)->GetData();
29370
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 {
29375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29376 }
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29384 PyObject *resultobj;
29385 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29386 wxDragResult arg2 ;
29387 PyObject * obj0 = 0 ;
29388 PyObject * obj1 = 0 ;
29389 char *kwnames[] = {
29390 (char *) "self",(char *) "action", NULL
29391 };
29392
29393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29395 if (SWIG_arg_fail(1)) SWIG_fail;
29396 {
29397 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29398 if (SWIG_arg_fail(2)) SWIG_fail;
29399 }
29400 {
29401 PyThreadState* __tstate = wxPyBeginAllowThreads();
29402 (arg1)->SetDefaultAction((wxDragResult )arg2);
29403
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 Py_INCREF(Py_None); resultobj = Py_None;
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29415 PyObject *resultobj;
29416 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29417 wxDragResult result;
29418 PyObject * obj0 = 0 ;
29419 char *kwnames[] = {
29420 (char *) "self", NULL
29421 };
29422
29423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29425 if (SWIG_arg_fail(1)) SWIG_fail;
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (wxDragResult)(arg1)->GetDefaultAction();
29429
29430 wxPyEndAllowThreads(__tstate);
29431 if (PyErr_Occurred()) SWIG_fail;
29432 }
29433 resultobj = SWIG_From_int((result));
29434 return resultobj;
29435 fail:
29436 return NULL;
29437 }
29438
29439
29440 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29441 PyObject *obj;
29442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29443 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29444 Py_INCREF(obj);
29445 return Py_BuildValue((char *)"");
29446 }
29447 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29448 PyObject *resultobj;
29449 wxPyTextDropTarget *result;
29450 char *kwnames[] = {
29451 NULL
29452 };
29453
29454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29455 {
29456 PyThreadState* __tstate = wxPyBeginAllowThreads();
29457 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29458
29459 wxPyEndAllowThreads(__tstate);
29460 if (PyErr_Occurred()) SWIG_fail;
29461 }
29462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29463 return resultobj;
29464 fail:
29465 return NULL;
29466 }
29467
29468
29469 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29470 PyObject *resultobj;
29471 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29472 PyObject *arg2 = (PyObject *) 0 ;
29473 PyObject *arg3 = (PyObject *) 0 ;
29474 PyObject * obj0 = 0 ;
29475 PyObject * obj1 = 0 ;
29476 PyObject * obj2 = 0 ;
29477 char *kwnames[] = {
29478 (char *) "self",(char *) "self",(char *) "_class", NULL
29479 };
29480
29481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29483 if (SWIG_arg_fail(1)) SWIG_fail;
29484 arg2 = obj1;
29485 arg3 = obj2;
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 (arg1)->_setCallbackInfo(arg2,arg3);
29489
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 Py_INCREF(Py_None); resultobj = Py_None;
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj;
29502 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29503 int arg2 ;
29504 int arg3 ;
29505 wxDragResult arg4 ;
29506 wxDragResult result;
29507 PyObject * obj0 = 0 ;
29508 PyObject * obj1 = 0 ;
29509 PyObject * obj2 = 0 ;
29510 PyObject * obj3 = 0 ;
29511 char *kwnames[] = {
29512 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29513 };
29514
29515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29517 if (SWIG_arg_fail(1)) SWIG_fail;
29518 {
29519 arg2 = (int)(SWIG_As_int(obj1));
29520 if (SWIG_arg_fail(2)) SWIG_fail;
29521 }
29522 {
29523 arg3 = (int)(SWIG_As_int(obj2));
29524 if (SWIG_arg_fail(3)) SWIG_fail;
29525 }
29526 {
29527 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29528 if (SWIG_arg_fail(4)) SWIG_fail;
29529 }
29530 {
29531 PyThreadState* __tstate = wxPyBeginAllowThreads();
29532 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29533
29534 wxPyEndAllowThreads(__tstate);
29535 if (PyErr_Occurred()) SWIG_fail;
29536 }
29537 resultobj = SWIG_From_int((result));
29538 return resultobj;
29539 fail:
29540 return NULL;
29541 }
29542
29543
29544 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29545 PyObject *resultobj;
29546 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29547 int arg2 ;
29548 int arg3 ;
29549 wxDragResult arg4 ;
29550 wxDragResult result;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 PyObject * obj2 = 0 ;
29554 PyObject * obj3 = 0 ;
29555 char *kwnames[] = {
29556 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29557 };
29558
29559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29561 if (SWIG_arg_fail(1)) SWIG_fail;
29562 {
29563 arg2 = (int)(SWIG_As_int(obj1));
29564 if (SWIG_arg_fail(2)) SWIG_fail;
29565 }
29566 {
29567 arg3 = (int)(SWIG_As_int(obj2));
29568 if (SWIG_arg_fail(3)) SWIG_fail;
29569 }
29570 {
29571 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29572 if (SWIG_arg_fail(4)) SWIG_fail;
29573 }
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29577
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 resultobj = SWIG_From_int((result));
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj;
29590 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29591 PyObject * obj0 = 0 ;
29592 char *kwnames[] = {
29593 (char *) "self", NULL
29594 };
29595
29596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29598 if (SWIG_arg_fail(1)) SWIG_fail;
29599 {
29600 PyThreadState* __tstate = wxPyBeginAllowThreads();
29601 (arg1)->base_OnLeave();
29602
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 Py_INCREF(Py_None); resultobj = Py_None;
29607 return resultobj;
29608 fail:
29609 return NULL;
29610 }
29611
29612
29613 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29614 PyObject *resultobj;
29615 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29616 int arg2 ;
29617 int arg3 ;
29618 bool result;
29619 PyObject * obj0 = 0 ;
29620 PyObject * obj1 = 0 ;
29621 PyObject * obj2 = 0 ;
29622 char *kwnames[] = {
29623 (char *) "self",(char *) "x",(char *) "y", NULL
29624 };
29625
29626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29628 if (SWIG_arg_fail(1)) SWIG_fail;
29629 {
29630 arg2 = (int)(SWIG_As_int(obj1));
29631 if (SWIG_arg_fail(2)) SWIG_fail;
29632 }
29633 {
29634 arg3 = (int)(SWIG_As_int(obj2));
29635 if (SWIG_arg_fail(3)) SWIG_fail;
29636 }
29637 {
29638 PyThreadState* __tstate = wxPyBeginAllowThreads();
29639 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29640
29641 wxPyEndAllowThreads(__tstate);
29642 if (PyErr_Occurred()) SWIG_fail;
29643 }
29644 {
29645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29646 }
29647 return resultobj;
29648 fail:
29649 return NULL;
29650 }
29651
29652
29653 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29654 PyObject *resultobj;
29655 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29656 int arg2 ;
29657 int arg3 ;
29658 wxDragResult arg4 ;
29659 wxDragResult result;
29660 PyObject * obj0 = 0 ;
29661 PyObject * obj1 = 0 ;
29662 PyObject * obj2 = 0 ;
29663 PyObject * obj3 = 0 ;
29664 char *kwnames[] = {
29665 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29666 };
29667
29668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29670 if (SWIG_arg_fail(1)) SWIG_fail;
29671 {
29672 arg2 = (int)(SWIG_As_int(obj1));
29673 if (SWIG_arg_fail(2)) SWIG_fail;
29674 }
29675 {
29676 arg3 = (int)(SWIG_As_int(obj2));
29677 if (SWIG_arg_fail(3)) SWIG_fail;
29678 }
29679 {
29680 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29681 if (SWIG_arg_fail(4)) SWIG_fail;
29682 }
29683 {
29684 PyThreadState* __tstate = wxPyBeginAllowThreads();
29685 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29686
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 resultobj = SWIG_From_int((result));
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29698 PyObject *obj;
29699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29700 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29701 Py_INCREF(obj);
29702 return Py_BuildValue((char *)"");
29703 }
29704 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29705 PyObject *resultobj;
29706 wxPyFileDropTarget *result;
29707 char *kwnames[] = {
29708 NULL
29709 };
29710
29711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29715
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj;
29728 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29729 PyObject *arg2 = (PyObject *) 0 ;
29730 PyObject *arg3 = (PyObject *) 0 ;
29731 PyObject * obj0 = 0 ;
29732 PyObject * obj1 = 0 ;
29733 PyObject * obj2 = 0 ;
29734 char *kwnames[] = {
29735 (char *) "self",(char *) "self",(char *) "_class", NULL
29736 };
29737
29738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29740 if (SWIG_arg_fail(1)) SWIG_fail;
29741 arg2 = obj1;
29742 arg3 = obj2;
29743 {
29744 PyThreadState* __tstate = wxPyBeginAllowThreads();
29745 (arg1)->_setCallbackInfo(arg2,arg3);
29746
29747 wxPyEndAllowThreads(__tstate);
29748 if (PyErr_Occurred()) SWIG_fail;
29749 }
29750 Py_INCREF(Py_None); resultobj = Py_None;
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj;
29759 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29760 int arg2 ;
29761 int arg3 ;
29762 wxDragResult arg4 ;
29763 wxDragResult result;
29764 PyObject * obj0 = 0 ;
29765 PyObject * obj1 = 0 ;
29766 PyObject * obj2 = 0 ;
29767 PyObject * obj3 = 0 ;
29768 char *kwnames[] = {
29769 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29770 };
29771
29772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29774 if (SWIG_arg_fail(1)) SWIG_fail;
29775 {
29776 arg2 = (int)(SWIG_As_int(obj1));
29777 if (SWIG_arg_fail(2)) SWIG_fail;
29778 }
29779 {
29780 arg3 = (int)(SWIG_As_int(obj2));
29781 if (SWIG_arg_fail(3)) SWIG_fail;
29782 }
29783 {
29784 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29785 if (SWIG_arg_fail(4)) SWIG_fail;
29786 }
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29790
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_From_int((result));
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj;
29803 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29804 int arg2 ;
29805 int arg3 ;
29806 wxDragResult arg4 ;
29807 wxDragResult result;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 PyObject * obj2 = 0 ;
29811 PyObject * obj3 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 {
29820 arg2 = (int)(SWIG_As_int(obj1));
29821 if (SWIG_arg_fail(2)) SWIG_fail;
29822 }
29823 {
29824 arg3 = (int)(SWIG_As_int(obj2));
29825 if (SWIG_arg_fail(3)) SWIG_fail;
29826 }
29827 {
29828 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29829 if (SWIG_arg_fail(4)) SWIG_fail;
29830 }
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29834
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 resultobj = SWIG_From_int((result));
29839 return resultobj;
29840 fail:
29841 return NULL;
29842 }
29843
29844
29845 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29846 PyObject *resultobj;
29847 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29848 PyObject * obj0 = 0 ;
29849 char *kwnames[] = {
29850 (char *) "self", NULL
29851 };
29852
29853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29855 if (SWIG_arg_fail(1)) SWIG_fail;
29856 {
29857 PyThreadState* __tstate = wxPyBeginAllowThreads();
29858 (arg1)->base_OnLeave();
29859
29860 wxPyEndAllowThreads(__tstate);
29861 if (PyErr_Occurred()) SWIG_fail;
29862 }
29863 Py_INCREF(Py_None); resultobj = Py_None;
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29871 PyObject *resultobj;
29872 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29873 int arg2 ;
29874 int arg3 ;
29875 bool result;
29876 PyObject * obj0 = 0 ;
29877 PyObject * obj1 = 0 ;
29878 PyObject * obj2 = 0 ;
29879 char *kwnames[] = {
29880 (char *) "self",(char *) "x",(char *) "y", NULL
29881 };
29882
29883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29885 if (SWIG_arg_fail(1)) SWIG_fail;
29886 {
29887 arg2 = (int)(SWIG_As_int(obj1));
29888 if (SWIG_arg_fail(2)) SWIG_fail;
29889 }
29890 {
29891 arg3 = (int)(SWIG_As_int(obj2));
29892 if (SWIG_arg_fail(3)) SWIG_fail;
29893 }
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29897
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 {
29902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29903 }
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29911 PyObject *resultobj;
29912 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29913 int arg2 ;
29914 int arg3 ;
29915 wxDragResult arg4 ;
29916 wxDragResult result;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 PyObject * obj2 = 0 ;
29920 PyObject * obj3 = 0 ;
29921 char *kwnames[] = {
29922 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29923 };
29924
29925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29927 if (SWIG_arg_fail(1)) SWIG_fail;
29928 {
29929 arg2 = (int)(SWIG_As_int(obj1));
29930 if (SWIG_arg_fail(2)) SWIG_fail;
29931 }
29932 {
29933 arg3 = (int)(SWIG_As_int(obj2));
29934 if (SWIG_arg_fail(3)) SWIG_fail;
29935 }
29936 {
29937 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29938 if (SWIG_arg_fail(4)) SWIG_fail;
29939 }
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_From_int((result));
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29955 PyObject *obj;
29956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29957 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29958 Py_INCREF(obj);
29959 return Py_BuildValue((char *)"");
29960 }
29961 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29962 PyObject *resultobj;
29963 wxClipboard *result;
29964 char *kwnames[] = {
29965 NULL
29966 };
29967
29968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 result = (wxClipboard *)new wxClipboard();
29972
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29977 return resultobj;
29978 fail:
29979 return NULL;
29980 }
29981
29982
29983 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29984 PyObject *resultobj;
29985 wxClipboard *arg1 = (wxClipboard *) 0 ;
29986 PyObject * obj0 = 0 ;
29987 char *kwnames[] = {
29988 (char *) "self", NULL
29989 };
29990
29991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29993 if (SWIG_arg_fail(1)) SWIG_fail;
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 delete arg1;
29997
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 Py_INCREF(Py_None); resultobj = Py_None;
30002 return resultobj;
30003 fail:
30004 return NULL;
30005 }
30006
30007
30008 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
30009 PyObject *resultobj;
30010 wxClipboard *arg1 = (wxClipboard *) 0 ;
30011 bool result;
30012 PyObject * obj0 = 0 ;
30013 char *kwnames[] = {
30014 (char *) "self", NULL
30015 };
30016
30017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
30018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30019 if (SWIG_arg_fail(1)) SWIG_fail;
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = (bool)(arg1)->Open();
30023
30024 wxPyEndAllowThreads(__tstate);
30025 if (PyErr_Occurred()) SWIG_fail;
30026 }
30027 {
30028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30029 }
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
30037 PyObject *resultobj;
30038 wxClipboard *arg1 = (wxClipboard *) 0 ;
30039 PyObject * obj0 = 0 ;
30040 char *kwnames[] = {
30041 (char *) "self", NULL
30042 };
30043
30044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
30045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30046 if (SWIG_arg_fail(1)) SWIG_fail;
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 (arg1)->Close();
30050
30051 wxPyEndAllowThreads(__tstate);
30052 if (PyErr_Occurred()) SWIG_fail;
30053 }
30054 Py_INCREF(Py_None); resultobj = Py_None;
30055 return resultobj;
30056 fail:
30057 return NULL;
30058 }
30059
30060
30061 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
30062 PyObject *resultobj;
30063 wxClipboard *arg1 = (wxClipboard *) 0 ;
30064 bool result;
30065 PyObject * obj0 = 0 ;
30066 char *kwnames[] = {
30067 (char *) "self", NULL
30068 };
30069
30070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
30071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30072 if (SWIG_arg_fail(1)) SWIG_fail;
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (bool)((wxClipboard const *)arg1)->IsOpened();
30076
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 {
30081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30082 }
30083 return resultobj;
30084 fail:
30085 return NULL;
30086 }
30087
30088
30089 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
30090 PyObject *resultobj;
30091 wxClipboard *arg1 = (wxClipboard *) 0 ;
30092 wxDataObject *arg2 = (wxDataObject *) 0 ;
30093 bool result;
30094 PyObject * obj0 = 0 ;
30095 PyObject * obj1 = 0 ;
30096 char *kwnames[] = {
30097 (char *) "self",(char *) "data", NULL
30098 };
30099
30100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
30101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30102 if (SWIG_arg_fail(1)) SWIG_fail;
30103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30104 if (SWIG_arg_fail(2)) SWIG_fail;
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (bool)(arg1)->AddData(arg2);
30108
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 {
30113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30114 }
30115 return resultobj;
30116 fail:
30117 return NULL;
30118 }
30119
30120
30121 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
30122 PyObject *resultobj;
30123 wxClipboard *arg1 = (wxClipboard *) 0 ;
30124 wxDataObject *arg2 = (wxDataObject *) 0 ;
30125 bool result;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "self",(char *) "data", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
30133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(1)) SWIG_fail;
30135 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30136 if (SWIG_arg_fail(2)) SWIG_fail;
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 result = (bool)(arg1)->SetData(arg2);
30140
30141 wxPyEndAllowThreads(__tstate);
30142 if (PyErr_Occurred()) SWIG_fail;
30143 }
30144 {
30145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30146 }
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
30154 PyObject *resultobj;
30155 wxClipboard *arg1 = (wxClipboard *) 0 ;
30156 wxDataFormat *arg2 = 0 ;
30157 bool result;
30158 PyObject * obj0 = 0 ;
30159 PyObject * obj1 = 0 ;
30160 char *kwnames[] = {
30161 (char *) "self",(char *) "format", NULL
30162 };
30163
30164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
30165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30166 if (SWIG_arg_fail(1)) SWIG_fail;
30167 {
30168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
30169 if (SWIG_arg_fail(2)) SWIG_fail;
30170 if (arg2 == NULL) {
30171 SWIG_null_ref("wxDataFormat");
30172 }
30173 if (SWIG_arg_fail(2)) SWIG_fail;
30174 }
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
30178
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30184 }
30185 return resultobj;
30186 fail:
30187 return NULL;
30188 }
30189
30190
30191 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj;
30193 wxClipboard *arg1 = (wxClipboard *) 0 ;
30194 wxDataObject *arg2 = 0 ;
30195 bool result;
30196 PyObject * obj0 = 0 ;
30197 PyObject * obj1 = 0 ;
30198 char *kwnames[] = {
30199 (char *) "self",(char *) "data", NULL
30200 };
30201
30202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30204 if (SWIG_arg_fail(1)) SWIG_fail;
30205 {
30206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30207 if (SWIG_arg_fail(2)) SWIG_fail;
30208 if (arg2 == NULL) {
30209 SWIG_null_ref("wxDataObject");
30210 }
30211 if (SWIG_arg_fail(2)) SWIG_fail;
30212 }
30213 {
30214 PyThreadState* __tstate = wxPyBeginAllowThreads();
30215 result = (bool)(arg1)->GetData(*arg2);
30216
30217 wxPyEndAllowThreads(__tstate);
30218 if (PyErr_Occurred()) SWIG_fail;
30219 }
30220 {
30221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30222 }
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30230 PyObject *resultobj;
30231 wxClipboard *arg1 = (wxClipboard *) 0 ;
30232 PyObject * obj0 = 0 ;
30233 char *kwnames[] = {
30234 (char *) "self", NULL
30235 };
30236
30237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30239 if (SWIG_arg_fail(1)) SWIG_fail;
30240 {
30241 PyThreadState* __tstate = wxPyBeginAllowThreads();
30242 (arg1)->Clear();
30243
30244 wxPyEndAllowThreads(__tstate);
30245 if (PyErr_Occurred()) SWIG_fail;
30246 }
30247 Py_INCREF(Py_None); resultobj = Py_None;
30248 return resultobj;
30249 fail:
30250 return NULL;
30251 }
30252
30253
30254 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30255 PyObject *resultobj;
30256 wxClipboard *arg1 = (wxClipboard *) 0 ;
30257 bool result;
30258 PyObject * obj0 = 0 ;
30259 char *kwnames[] = {
30260 (char *) "self", NULL
30261 };
30262
30263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30265 if (SWIG_arg_fail(1)) SWIG_fail;
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 result = (bool)(arg1)->Flush();
30269
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 {
30274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30275 }
30276 return resultobj;
30277 fail:
30278 return NULL;
30279 }
30280
30281
30282 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30283 PyObject *resultobj;
30284 wxClipboard *arg1 = (wxClipboard *) 0 ;
30285 bool arg2 = (bool) true ;
30286 PyObject * obj0 = 0 ;
30287 PyObject * obj1 = 0 ;
30288 char *kwnames[] = {
30289 (char *) "self",(char *) "primary", NULL
30290 };
30291
30292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30294 if (SWIG_arg_fail(1)) SWIG_fail;
30295 if (obj1) {
30296 {
30297 arg2 = (bool)(SWIG_As_bool(obj1));
30298 if (SWIG_arg_fail(2)) SWIG_fail;
30299 }
30300 }
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 (arg1)->UsePrimarySelection(arg2);
30304
30305 wxPyEndAllowThreads(__tstate);
30306 if (PyErr_Occurred()) SWIG_fail;
30307 }
30308 Py_INCREF(Py_None); resultobj = Py_None;
30309 return resultobj;
30310 fail:
30311 return NULL;
30312 }
30313
30314
30315 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30316 PyObject *resultobj;
30317 wxClipboard *result;
30318 char *kwnames[] = {
30319 NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (wxClipboard *)wxClipboard::Get();
30326
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30338 PyObject *obj;
30339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30340 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30341 Py_INCREF(obj);
30342 return Py_BuildValue((char *)"");
30343 }
30344 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30345 PyObject *resultobj;
30346 wxClipboard *arg1 = (wxClipboard *) NULL ;
30347 wxClipboardLocker *result;
30348 PyObject * obj0 = 0 ;
30349 char *kwnames[] = {
30350 (char *) "clipboard", NULL
30351 };
30352
30353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30354 if (obj0) {
30355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30356 if (SWIG_arg_fail(1)) SWIG_fail;
30357 }
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30361
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30366 return resultobj;
30367 fail:
30368 return NULL;
30369 }
30370
30371
30372 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30373 PyObject *resultobj;
30374 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30375 PyObject * obj0 = 0 ;
30376 char *kwnames[] = {
30377 (char *) "self", NULL
30378 };
30379
30380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30382 if (SWIG_arg_fail(1)) SWIG_fail;
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 delete arg1;
30386
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 Py_INCREF(Py_None); resultobj = Py_None;
30391 return resultobj;
30392 fail:
30393 return NULL;
30394 }
30395
30396
30397 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30398 PyObject *resultobj;
30399 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30400 bool result;
30401 PyObject * obj0 = 0 ;
30402 char *kwnames[] = {
30403 (char *) "self", NULL
30404 };
30405
30406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30408 if (SWIG_arg_fail(1)) SWIG_fail;
30409 {
30410 PyThreadState* __tstate = wxPyBeginAllowThreads();
30411 result = (bool)wxClipboardLocker___nonzero__(arg1);
30412
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 {
30417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30418 }
30419 return resultobj;
30420 fail:
30421 return NULL;
30422 }
30423
30424
30425 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30426 PyObject *obj;
30427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30428 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30429 Py_INCREF(obj);
30430 return Py_BuildValue((char *)"");
30431 }
30432 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30433 PyObject *resultobj;
30434 int arg1 = (int) 0 ;
30435 int arg2 = (int) 0 ;
30436 int arg3 = (int) 0 ;
30437 int arg4 = (int) 0 ;
30438 wxVideoMode *result;
30439 PyObject * obj0 = 0 ;
30440 PyObject * obj1 = 0 ;
30441 PyObject * obj2 = 0 ;
30442 PyObject * obj3 = 0 ;
30443 char *kwnames[] = {
30444 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30445 };
30446
30447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30448 if (obj0) {
30449 {
30450 arg1 = (int)(SWIG_As_int(obj0));
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 }
30453 }
30454 if (obj1) {
30455 {
30456 arg2 = (int)(SWIG_As_int(obj1));
30457 if (SWIG_arg_fail(2)) SWIG_fail;
30458 }
30459 }
30460 if (obj2) {
30461 {
30462 arg3 = (int)(SWIG_As_int(obj2));
30463 if (SWIG_arg_fail(3)) SWIG_fail;
30464 }
30465 }
30466 if (obj3) {
30467 {
30468 arg4 = (int)(SWIG_As_int(obj3));
30469 if (SWIG_arg_fail(4)) SWIG_fail;
30470 }
30471 }
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30475
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj;
30488 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30489 PyObject * obj0 = 0 ;
30490 char *kwnames[] = {
30491 (char *) "self", NULL
30492 };
30493
30494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30496 if (SWIG_arg_fail(1)) SWIG_fail;
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 delete arg1;
30500
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 Py_INCREF(Py_None); resultobj = Py_None;
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj;
30513 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30514 wxVideoMode *arg2 = 0 ;
30515 bool result;
30516 PyObject * obj0 = 0 ;
30517 PyObject * obj1 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self",(char *) "other", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 {
30526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30527 if (SWIG_arg_fail(2)) SWIG_fail;
30528 if (arg2 == NULL) {
30529 SWIG_null_ref("wxVideoMode");
30530 }
30531 if (SWIG_arg_fail(2)) SWIG_fail;
30532 }
30533 {
30534 PyThreadState* __tstate = wxPyBeginAllowThreads();
30535 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30536
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 {
30541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30552 int result;
30553 PyObject * obj0 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30564
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 {
30569 resultobj = SWIG_From_int((int)(result));
30570 }
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj;
30579 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30580 int result;
30581 PyObject * obj0 = 0 ;
30582 char *kwnames[] = {
30583 (char *) "self", NULL
30584 };
30585
30586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30588 if (SWIG_arg_fail(1)) SWIG_fail;
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30592
30593 wxPyEndAllowThreads(__tstate);
30594 if (PyErr_Occurred()) SWIG_fail;
30595 }
30596 {
30597 resultobj = SWIG_From_int((int)(result));
30598 }
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj;
30607 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30608 int result;
30609 PyObject * obj0 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30620
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 {
30625 resultobj = SWIG_From_int((int)(result));
30626 }
30627 return resultobj;
30628 fail:
30629 return NULL;
30630 }
30631
30632
30633 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30634 PyObject *resultobj;
30635 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30636 bool result;
30637 PyObject * obj0 = 0 ;
30638 char *kwnames[] = {
30639 (char *) "self", NULL
30640 };
30641
30642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30644 if (SWIG_arg_fail(1)) SWIG_fail;
30645 {
30646 PyThreadState* __tstate = wxPyBeginAllowThreads();
30647 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30648
30649 wxPyEndAllowThreads(__tstate);
30650 if (PyErr_Occurred()) SWIG_fail;
30651 }
30652 {
30653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30654 }
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj;
30663 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30664 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30665 bool result;
30666 PyObject * obj0 = 0 ;
30667 PyObject * obj1 = 0 ;
30668 char *kwnames[] = {
30669 (char *) "self",(char *) "other", NULL
30670 };
30671
30672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30674 if (SWIG_arg_fail(1)) SWIG_fail;
30675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30676 if (SWIG_arg_fail(2)) SWIG_fail;
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30680
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 {
30685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30686 }
30687 return resultobj;
30688 fail:
30689 return NULL;
30690 }
30691
30692
30693 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30694 PyObject *resultobj;
30695 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30696 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30697 bool result;
30698 PyObject * obj0 = 0 ;
30699 PyObject * obj1 = 0 ;
30700 char *kwnames[] = {
30701 (char *) "self",(char *) "other", NULL
30702 };
30703
30704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30706 if (SWIG_arg_fail(1)) SWIG_fail;
30707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30708 if (SWIG_arg_fail(2)) SWIG_fail;
30709 {
30710 PyThreadState* __tstate = wxPyBeginAllowThreads();
30711 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30712
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 {
30717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30718 }
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30726 PyObject *resultobj;
30727 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30728 int arg2 ;
30729 PyObject * obj0 = 0 ;
30730 PyObject * obj1 = 0 ;
30731 char *kwnames[] = {
30732 (char *) "self",(char *) "w", NULL
30733 };
30734
30735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30737 if (SWIG_arg_fail(1)) SWIG_fail;
30738 {
30739 arg2 = (int)(SWIG_As_int(obj1));
30740 if (SWIG_arg_fail(2)) SWIG_fail;
30741 }
30742 if (arg1) (arg1)->w = arg2;
30743
30744 Py_INCREF(Py_None); resultobj = Py_None;
30745 return resultobj;
30746 fail:
30747 return NULL;
30748 }
30749
30750
30751 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30752 PyObject *resultobj;
30753 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30754 int result;
30755 PyObject * obj0 = 0 ;
30756 char *kwnames[] = {
30757 (char *) "self", NULL
30758 };
30759
30760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30762 if (SWIG_arg_fail(1)) SWIG_fail;
30763 result = (int) ((arg1)->w);
30764
30765 {
30766 resultobj = SWIG_From_int((int)(result));
30767 }
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30775 PyObject *resultobj;
30776 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30777 int arg2 ;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 char *kwnames[] = {
30781 (char *) "self",(char *) "h", NULL
30782 };
30783
30784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30786 if (SWIG_arg_fail(1)) SWIG_fail;
30787 {
30788 arg2 = (int)(SWIG_As_int(obj1));
30789 if (SWIG_arg_fail(2)) SWIG_fail;
30790 }
30791 if (arg1) (arg1)->h = arg2;
30792
30793 Py_INCREF(Py_None); resultobj = Py_None;
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30801 PyObject *resultobj;
30802 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30803 int result;
30804 PyObject * obj0 = 0 ;
30805 char *kwnames[] = {
30806 (char *) "self", NULL
30807 };
30808
30809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30811 if (SWIG_arg_fail(1)) SWIG_fail;
30812 result = (int) ((arg1)->h);
30813
30814 {
30815 resultobj = SWIG_From_int((int)(result));
30816 }
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30824 PyObject *resultobj;
30825 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30826 int arg2 ;
30827 PyObject * obj0 = 0 ;
30828 PyObject * obj1 = 0 ;
30829 char *kwnames[] = {
30830 (char *) "self",(char *) "bpp", NULL
30831 };
30832
30833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30835 if (SWIG_arg_fail(1)) SWIG_fail;
30836 {
30837 arg2 = (int)(SWIG_As_int(obj1));
30838 if (SWIG_arg_fail(2)) SWIG_fail;
30839 }
30840 if (arg1) (arg1)->bpp = arg2;
30841
30842 Py_INCREF(Py_None); resultobj = Py_None;
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30850 PyObject *resultobj;
30851 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30852 int result;
30853 PyObject * obj0 = 0 ;
30854 char *kwnames[] = {
30855 (char *) "self", NULL
30856 };
30857
30858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30860 if (SWIG_arg_fail(1)) SWIG_fail;
30861 result = (int) ((arg1)->bpp);
30862
30863 {
30864 resultobj = SWIG_From_int((int)(result));
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj;
30874 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30875 int arg2 ;
30876 PyObject * obj0 = 0 ;
30877 PyObject * obj1 = 0 ;
30878 char *kwnames[] = {
30879 (char *) "self",(char *) "refresh", NULL
30880 };
30881
30882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30884 if (SWIG_arg_fail(1)) SWIG_fail;
30885 {
30886 arg2 = (int)(SWIG_As_int(obj1));
30887 if (SWIG_arg_fail(2)) SWIG_fail;
30888 }
30889 if (arg1) (arg1)->refresh = arg2;
30890
30891 Py_INCREF(Py_None); resultobj = Py_None;
30892 return resultobj;
30893 fail:
30894 return NULL;
30895 }
30896
30897
30898 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30899 PyObject *resultobj;
30900 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30901 int result;
30902 PyObject * obj0 = 0 ;
30903 char *kwnames[] = {
30904 (char *) "self", NULL
30905 };
30906
30907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30909 if (SWIG_arg_fail(1)) SWIG_fail;
30910 result = (int) ((arg1)->refresh);
30911
30912 {
30913 resultobj = SWIG_From_int((int)(result));
30914 }
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30922 PyObject *obj;
30923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30924 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30925 Py_INCREF(obj);
30926 return Py_BuildValue((char *)"");
30927 }
30928 static int _wrap_DefaultVideoMode_set(PyObject *) {
30929 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30930 return 1;
30931 }
30932
30933
30934 static PyObject *_wrap_DefaultVideoMode_get(void) {
30935 PyObject *pyobj;
30936
30937 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30938 return pyobj;
30939 }
30940
30941
30942 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30943 PyObject *resultobj;
30944 size_t arg1 = (size_t) 0 ;
30945 wxDisplay *result;
30946 PyObject * obj0 = 0 ;
30947 char *kwnames[] = {
30948 (char *) "index", NULL
30949 };
30950
30951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30952 if (obj0) {
30953 {
30954 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30955 if (SWIG_arg_fail(1)) SWIG_fail;
30956 }
30957 }
30958 {
30959 PyThreadState* __tstate = wxPyBeginAllowThreads();
30960 result = (wxDisplay *)new wxDisplay(arg1);
30961
30962 wxPyEndAllowThreads(__tstate);
30963 if (PyErr_Occurred()) SWIG_fail;
30964 }
30965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30966 return resultobj;
30967 fail:
30968 return NULL;
30969 }
30970
30971
30972 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30973 PyObject *resultobj;
30974 wxDisplay *arg1 = (wxDisplay *) 0 ;
30975 PyObject * obj0 = 0 ;
30976 char *kwnames[] = {
30977 (char *) "self", NULL
30978 };
30979
30980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30982 if (SWIG_arg_fail(1)) SWIG_fail;
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 delete arg1;
30986
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 Py_INCREF(Py_None); resultobj = Py_None;
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30998 PyObject *resultobj;
30999 size_t result;
31000 char *kwnames[] = {
31001 NULL
31002 };
31003
31004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (size_t)wxDisplay::GetCount();
31008
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj;
31023 wxPoint *arg1 = 0 ;
31024 int result;
31025 wxPoint temp1 ;
31026 PyObject * obj0 = 0 ;
31027 char *kwnames[] = {
31028 (char *) "pt", NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
31032 {
31033 arg1 = &temp1;
31034 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
31035 }
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
31039
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 {
31044 resultobj = SWIG_From_int((int)(result));
31045 }
31046 return resultobj;
31047 fail:
31048 return NULL;
31049 }
31050
31051
31052 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31053 PyObject *resultobj;
31054 wxWindow *arg1 = (wxWindow *) 0 ;
31055 int result;
31056 PyObject * obj0 = 0 ;
31057 char *kwnames[] = {
31058 (char *) "window", NULL
31059 };
31060
31061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
31062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31063 if (SWIG_arg_fail(1)) SWIG_fail;
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 result = (int)Display_GetFromWindow(arg1);
31067
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 {
31072 resultobj = SWIG_From_int((int)(result));
31073 }
31074 return resultobj;
31075 fail:
31076 return NULL;
31077 }
31078
31079
31080 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31081 PyObject *resultobj;
31082 wxDisplay *arg1 = (wxDisplay *) 0 ;
31083 bool result;
31084 PyObject * obj0 = 0 ;
31085 char *kwnames[] = {
31086 (char *) "self", NULL
31087 };
31088
31089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
31090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31091 if (SWIG_arg_fail(1)) SWIG_fail;
31092 {
31093 PyThreadState* __tstate = wxPyBeginAllowThreads();
31094 result = (bool)((wxDisplay const *)arg1)->IsOk();
31095
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 {
31100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31101 }
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
31109 PyObject *resultobj;
31110 wxDisplay *arg1 = (wxDisplay *) 0 ;
31111 wxRect result;
31112 PyObject * obj0 = 0 ;
31113 char *kwnames[] = {
31114 (char *) "self", NULL
31115 };
31116
31117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
31118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31119 if (SWIG_arg_fail(1)) SWIG_fail;
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 result = ((wxDisplay const *)arg1)->GetGeometry();
31123
31124 wxPyEndAllowThreads(__tstate);
31125 if (PyErr_Occurred()) SWIG_fail;
31126 }
31127 {
31128 wxRect * resultptr;
31129 resultptr = new wxRect((wxRect &)(result));
31130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
31131 }
31132 return resultobj;
31133 fail:
31134 return NULL;
31135 }
31136
31137
31138 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
31139 PyObject *resultobj;
31140 wxDisplay *arg1 = (wxDisplay *) 0 ;
31141 wxString result;
31142 PyObject * obj0 = 0 ;
31143 char *kwnames[] = {
31144 (char *) "self", NULL
31145 };
31146
31147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
31148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31149 if (SWIG_arg_fail(1)) SWIG_fail;
31150 {
31151 PyThreadState* __tstate = wxPyBeginAllowThreads();
31152 result = ((wxDisplay const *)arg1)->GetName();
31153
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 {
31158 #if wxUSE_UNICODE
31159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31160 #else
31161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31162 #endif
31163 }
31164 return resultobj;
31165 fail:
31166 return NULL;
31167 }
31168
31169
31170 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
31171 PyObject *resultobj;
31172 wxDisplay *arg1 = (wxDisplay *) 0 ;
31173 bool result;
31174 PyObject * obj0 = 0 ;
31175 char *kwnames[] = {
31176 (char *) "self", NULL
31177 };
31178
31179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
31180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31181 if (SWIG_arg_fail(1)) SWIG_fail;
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
31185
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 {
31190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31191 }
31192 return resultobj;
31193 fail:
31194 return NULL;
31195 }
31196
31197
31198 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
31199 PyObject *resultobj;
31200 wxDisplay *arg1 = (wxDisplay *) 0 ;
31201 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31202 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31203 PyObject *result;
31204 PyObject * obj0 = 0 ;
31205 PyObject * obj1 = 0 ;
31206 char *kwnames[] = {
31207 (char *) "self",(char *) "mode", NULL
31208 };
31209
31210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31212 if (SWIG_arg_fail(1)) SWIG_fail;
31213 if (obj1) {
31214 {
31215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31216 if (SWIG_arg_fail(2)) SWIG_fail;
31217 if (arg2 == NULL) {
31218 SWIG_null_ref("wxVideoMode");
31219 }
31220 if (SWIG_arg_fail(2)) SWIG_fail;
31221 }
31222 }
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 resultobj = result;
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj;
31239 wxDisplay *arg1 = (wxDisplay *) 0 ;
31240 wxVideoMode result;
31241 PyObject * obj0 = 0 ;
31242 char *kwnames[] = {
31243 (char *) "self", NULL
31244 };
31245
31246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31248 if (SWIG_arg_fail(1)) SWIG_fail;
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31252
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 {
31257 wxVideoMode * resultptr;
31258 resultptr = new wxVideoMode((wxVideoMode &)(result));
31259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31260 }
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31268 PyObject *resultobj;
31269 wxDisplay *arg1 = (wxDisplay *) 0 ;
31270 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31271 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31272 bool result;
31273 PyObject * obj0 = 0 ;
31274 PyObject * obj1 = 0 ;
31275 char *kwnames[] = {
31276 (char *) "self",(char *) "mode", NULL
31277 };
31278
31279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31281 if (SWIG_arg_fail(1)) SWIG_fail;
31282 if (obj1) {
31283 {
31284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31285 if (SWIG_arg_fail(2)) SWIG_fail;
31286 if (arg2 == NULL) {
31287 SWIG_null_ref("wxVideoMode");
31288 }
31289 if (SWIG_arg_fail(2)) SWIG_fail;
31290 }
31291 }
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31295
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 {
31300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31301 }
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31309 PyObject *resultobj;
31310 wxDisplay *arg1 = (wxDisplay *) 0 ;
31311 PyObject * obj0 = 0 ;
31312 char *kwnames[] = {
31313 (char *) "self", NULL
31314 };
31315
31316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31318 if (SWIG_arg_fail(1)) SWIG_fail;
31319 {
31320 PyThreadState* __tstate = wxPyBeginAllowThreads();
31321 (arg1)->ResetMode();
31322
31323 wxPyEndAllowThreads(__tstate);
31324 if (PyErr_Occurred()) SWIG_fail;
31325 }
31326 Py_INCREF(Py_None); resultobj = Py_None;
31327 return resultobj;
31328 fail:
31329 return NULL;
31330 }
31331
31332
31333 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31334 PyObject *obj;
31335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31336 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31337 Py_INCREF(obj);
31338 return Py_BuildValue((char *)"");
31339 }
31340 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31341 PyObject *resultobj;
31342 wxStandardPaths *result;
31343 char *kwnames[] = {
31344 NULL
31345 };
31346
31347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = (wxStandardPaths *)StandardPaths_Get();
31351
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31363 PyObject *resultobj;
31364 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31365 wxString result;
31366 PyObject * obj0 = 0 ;
31367 char *kwnames[] = {
31368 (char *) "self", NULL
31369 };
31370
31371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31373 if (SWIG_arg_fail(1)) SWIG_fail;
31374 {
31375 PyThreadState* __tstate = wxPyBeginAllowThreads();
31376 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31377
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 {
31382 #if wxUSE_UNICODE
31383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31384 #else
31385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31386 #endif
31387 }
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31395 PyObject *resultobj;
31396 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31397 wxString result;
31398 PyObject * obj0 = 0 ;
31399 char *kwnames[] = {
31400 (char *) "self", NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31405 if (SWIG_arg_fail(1)) SWIG_fail;
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31409
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 {
31414 #if wxUSE_UNICODE
31415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31416 #else
31417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31418 #endif
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj;
31428 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31429 wxString result;
31430 PyObject * obj0 = 0 ;
31431 char *kwnames[] = {
31432 (char *) "self", NULL
31433 };
31434
31435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31437 if (SWIG_arg_fail(1)) SWIG_fail;
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31441
31442 wxPyEndAllowThreads(__tstate);
31443 if (PyErr_Occurred()) SWIG_fail;
31444 }
31445 {
31446 #if wxUSE_UNICODE
31447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31448 #else
31449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31450 #endif
31451 }
31452 return resultobj;
31453 fail:
31454 return NULL;
31455 }
31456
31457
31458 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31459 PyObject *resultobj;
31460 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31461 wxString result;
31462 PyObject * obj0 = 0 ;
31463 char *kwnames[] = {
31464 (char *) "self", NULL
31465 };
31466
31467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31469 if (SWIG_arg_fail(1)) SWIG_fail;
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31473
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 {
31478 #if wxUSE_UNICODE
31479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31480 #else
31481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31482 #endif
31483 }
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj;
31492 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31493 wxString result;
31494 PyObject * obj0 = 0 ;
31495 char *kwnames[] = {
31496 (char *) "self", NULL
31497 };
31498
31499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31501 if (SWIG_arg_fail(1)) SWIG_fail;
31502 {
31503 PyThreadState* __tstate = wxPyBeginAllowThreads();
31504 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31505
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 {
31510 #if wxUSE_UNICODE
31511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31512 #else
31513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31514 #endif
31515 }
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31523 PyObject *resultobj;
31524 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31525 wxString result;
31526 PyObject * obj0 = 0 ;
31527 char *kwnames[] = {
31528 (char *) "self", NULL
31529 };
31530
31531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31533 if (SWIG_arg_fail(1)) SWIG_fail;
31534 {
31535 PyThreadState* __tstate = wxPyBeginAllowThreads();
31536 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31537
31538 wxPyEndAllowThreads(__tstate);
31539 if (PyErr_Occurred()) SWIG_fail;
31540 }
31541 {
31542 #if wxUSE_UNICODE
31543 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31544 #else
31545 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31546 #endif
31547 }
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31555 PyObject *resultobj;
31556 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31557 wxString result;
31558 PyObject * obj0 = 0 ;
31559 char *kwnames[] = {
31560 (char *) "self", NULL
31561 };
31562
31563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31565 if (SWIG_arg_fail(1)) SWIG_fail;
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31569
31570 wxPyEndAllowThreads(__tstate);
31571 if (PyErr_Occurred()) SWIG_fail;
31572 }
31573 {
31574 #if wxUSE_UNICODE
31575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31576 #else
31577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31578 #endif
31579 }
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31587 PyObject *resultobj;
31588 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31589 wxString *arg2 = 0 ;
31590 bool temp2 = false ;
31591 PyObject * obj0 = 0 ;
31592 PyObject * obj1 = 0 ;
31593 char *kwnames[] = {
31594 (char *) "self",(char *) "prefix", NULL
31595 };
31596
31597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31599 if (SWIG_arg_fail(1)) SWIG_fail;
31600 {
31601 arg2 = wxString_in_helper(obj1);
31602 if (arg2 == NULL) SWIG_fail;
31603 temp2 = true;
31604 }
31605 {
31606 PyThreadState* __tstate = wxPyBeginAllowThreads();
31607 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31608
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 Py_INCREF(Py_None); resultobj = Py_None;
31613 {
31614 if (temp2)
31615 delete arg2;
31616 }
31617 return resultobj;
31618 fail:
31619 {
31620 if (temp2)
31621 delete arg2;
31622 }
31623 return NULL;
31624 }
31625
31626
31627 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31628 PyObject *resultobj;
31629 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31630 wxString result;
31631 PyObject * obj0 = 0 ;
31632 char *kwnames[] = {
31633 (char *) "self", NULL
31634 };
31635
31636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31638 if (SWIG_arg_fail(1)) SWIG_fail;
31639 {
31640 PyThreadState* __tstate = wxPyBeginAllowThreads();
31641 result = wxStandardPaths_GetInstallPrefix(arg1);
31642
31643 wxPyEndAllowThreads(__tstate);
31644 if (PyErr_Occurred()) SWIG_fail;
31645 }
31646 {
31647 #if wxUSE_UNICODE
31648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31649 #else
31650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31651 #endif
31652 }
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31660 PyObject *obj;
31661 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31662 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31663 Py_INCREF(obj);
31664 return Py_BuildValue((char *)"");
31665 }
31666 static PyMethodDef SwigMethods[] = {
31667 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31674 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31682 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31748 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31756 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31774 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31777 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31780 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31783 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31789 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31803 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31809 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31815 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31818 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31832 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31835 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31836 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31839 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31866 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31868 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31870 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31872 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31879 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31885 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
31889 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31903 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31907 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31910 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31927 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31935 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31982 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
32000 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
32010 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
32026 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
32042 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
32056 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
32066 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
32109 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
32112 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
32115 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
32119 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32212 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32213 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32214 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32215 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32232 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32245 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32259 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32270 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32271 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32272 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32273 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32274 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32275 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32276 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32277 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32278 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32279 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32280 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32281 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32282 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32283 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32284 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32285 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32286 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32287 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32288 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32289 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32290 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32291 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32292 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32293 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32294 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32295 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32296 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32297 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32298 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32299 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32300 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32301 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32302 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32303 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32304 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32305 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32306 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32307 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32308 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32309 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32310 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32311 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32312 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32313 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32314 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32315 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32316 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32317 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32318 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32319 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32320 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32321 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32322 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32323 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32324 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32325 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32326 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32327 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32328 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32329 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32330 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32331 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32332 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32333 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32334 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32335 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32336 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32337 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32338 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32339 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32340 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32341 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32342 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32343 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32344 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32345 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32346 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32347 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32348 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32349 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32350 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32351 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32352 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32353 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32354 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32355 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32356 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32357 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32358 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32359 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32360 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32361 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32362 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32363 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32364 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32365 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32366 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32367 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32368 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32369 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32370 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32371 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32372 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32373 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32374 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32375 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32376 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32377 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32378 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32379 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32380 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32381 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32382 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32383 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32384 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32385 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32386 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32387 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32388 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32389 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32390 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32391 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32392 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32393 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32394 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32395 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32396 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32397 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32398 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32399 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32400 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32401 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32402 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32403 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32404 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32405 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32406 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32407 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32408 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32409 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32410 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32411 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32412 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32413 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32414 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32415 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32416 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32417 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32418 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32419 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32420 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32421 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32422 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32423 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32424 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32425 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32426 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32427 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32428 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32429 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32430 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32431 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32432 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32433 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32434 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32435 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32436 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32437 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32438 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32439 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32440 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32441 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32442 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32443 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32444 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32445 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32446 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32447 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32448 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32449 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32450 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32451 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32452 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32453 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32454 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32455 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32456 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32457 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32458 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32459 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32460 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32461 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32462 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32463 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32464 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32465 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32466 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32467 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32468 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32469 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32470 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32471 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32472 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32473 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32474 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32475 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32476 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32477 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32478 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32479 { NULL, NULL, 0, NULL }
32480 };
32481
32482
32483 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32484
32485 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32486 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32487 }
32488 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32489 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32490 }
32491 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32492 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32493 }
32494 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32495 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32496 }
32497 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32498 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32499 }
32500 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32501 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32502 }
32503 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32504 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32505 }
32506 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32507 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32508 }
32509 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32510 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32511 }
32512 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32513 return (void *)((wxEvent *) ((wxPyEvent *) x));
32514 }
32515 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32516 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32517 }
32518 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32519 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32520 }
32521 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32522 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32523 }
32524 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32525 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32526 }
32527 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32528 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32529 }
32530 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32531 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32532 }
32533 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32534 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32535 }
32536 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32537 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32538 }
32539 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32540 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32541 }
32542 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32543 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32544 }
32545 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32546 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32547 }
32548 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32549 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32550 }
32551 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32552 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32553 }
32554 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32555 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32556 }
32557 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32558 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32559 }
32560 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32561 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32562 }
32563 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32564 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32565 }
32566 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32567 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32568 }
32569 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32570 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32571 }
32572 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32573 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32574 }
32575 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32576 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32577 }
32578 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32579 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32580 }
32581 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32582 return (void *)((wxEvent *) ((wxShowEvent *) x));
32583 }
32584 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32585 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32586 }
32587 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32588 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32589 }
32590 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32591 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32592 }
32593 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32594 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32595 }
32596 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32597 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32598 }
32599 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32600 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32601 }
32602 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32603 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32604 }
32605 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32606 return (void *)((wxConfigBase *) ((wxConfig *) x));
32607 }
32608 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32609 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32610 }
32611 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32612 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32613 }
32614 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32615 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32616 }
32617 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32618 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32619 }
32620 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32621 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32622 }
32623 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32624 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32625 }
32626 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32627 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32628 }
32629 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32630 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32631 }
32632 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32633 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32634 }
32635 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32636 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32637 }
32638 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32639 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32640 }
32641 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32642 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32643 }
32644 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32645 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32646 }
32647 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32648 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32649 }
32650 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32651 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32652 }
32653 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32654 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32655 }
32656 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32657 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32658 }
32659 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32660 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32661 }
32662 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32663 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32664 }
32665 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32666 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32667 }
32668 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32669 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32670 }
32671 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32672 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32673 }
32674 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32675 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32676 }
32677 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32678 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32679 }
32680 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32681 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32682 }
32683 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32684 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32685 }
32686 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32687 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32688 }
32689 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32690 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32691 }
32692 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32693 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32694 }
32695 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32696 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32697 }
32698 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32699 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32700 }
32701 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32702 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32703 }
32704 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32705 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32706 }
32707 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32708 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32709 }
32710 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32711 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32712 }
32713 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32714 return (void *)((wxObject *) ((wxSizerItem *) x));
32715 }
32716 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32717 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32718 }
32719 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32720 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32721 }
32722 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32723 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32724 }
32725 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32726 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32727 }
32728 static void *_p_wxSizerTo_p_wxObject(void *x) {
32729 return (void *)((wxObject *) ((wxSizer *) x));
32730 }
32731 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32732 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32733 }
32734 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32735 return (void *)((wxObject *) ((wxFileHistory *) x));
32736 }
32737 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32738 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32739 }
32740 static void *_p_wxEventTo_p_wxObject(void *x) {
32741 return (void *)((wxObject *) ((wxEvent *) x));
32742 }
32743 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32744 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32745 }
32746 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32747 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32748 }
32749 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32750 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32751 }
32752 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32753 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32754 }
32755 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32756 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32757 }
32758 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32759 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32760 }
32761 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32762 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32763 }
32764 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32765 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32766 }
32767 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32768 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32769 }
32770 static void *_p_wxControlTo_p_wxObject(void *x) {
32771 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32772 }
32773 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32774 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32775 }
32776 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32777 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32778 }
32779 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32780 return (void *)((wxObject *) ((wxFSFile *) x));
32781 }
32782 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32783 return (void *)((wxObject *) ((wxClipboard *) x));
32784 }
32785 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32786 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32787 }
32788 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32789 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32790 }
32791 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32792 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32793 }
32794 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32795 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32796 }
32797 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32798 return (void *)((wxObject *) ((wxToolTip *) x));
32799 }
32800 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32801 return (void *)((wxObject *) ((wxMenuItem *) x));
32802 }
32803 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32804 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32805 }
32806 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32807 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32808 }
32809 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32810 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32811 }
32812 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32813 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32814 }
32815 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32816 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32817 }
32818 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32819 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32820 }
32821 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32822 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32823 }
32824 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32825 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32826 }
32827 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32828 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32829 }
32830 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32831 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32832 }
32833 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32834 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32835 }
32836 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32837 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32838 }
32839 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32840 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32841 }
32842 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32843 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32844 }
32845 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32846 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32847 }
32848 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32849 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32850 }
32851 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32852 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32853 }
32854 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32855 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32856 }
32857 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32858 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32859 }
32860 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32861 return (void *)((wxObject *) ((wxImageHandler *) x));
32862 }
32863 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32864 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32865 }
32866 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32867 return (void *)((wxObject *) ((wxEvtHandler *) x));
32868 }
32869 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32870 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32871 }
32872 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32873 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32874 }
32875 static void *_p_wxImageTo_p_wxObject(void *x) {
32876 return (void *)((wxObject *) ((wxImage *) x));
32877 }
32878 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32879 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32880 }
32881 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32882 return (void *)((wxObject *) ((wxSystemOptions *) x));
32883 }
32884 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32885 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32886 }
32887 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32888 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32889 }
32890 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32891 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32892 }
32893 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32894 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32895 }
32896 static void *_p_wxWindowTo_p_wxObject(void *x) {
32897 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32898 }
32899 static void *_p_wxMenuTo_p_wxObject(void *x) {
32900 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32901 }
32902 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32903 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32904 }
32905 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32906 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32907 }
32908 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32909 return (void *)((wxObject *) ((wxFileSystem *) x));
32910 }
32911 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32912 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32913 }
32914 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32915 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32916 }
32917 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32918 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32919 }
32920 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32921 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32922 }
32923 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32924 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32925 }
32926 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32927 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32928 }
32929 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32930 return (void *)((wxObject *) ((wxBusyInfo *) x));
32931 }
32932 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32933 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32934 }
32935 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32936 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32937 }
32938 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32939 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32940 }
32941 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32942 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32943 }
32944 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32945 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32946 }
32947 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32948 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32949 }
32950 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32951 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32952 }
32953 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32954 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32955 }
32956 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32957 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32958 }
32959 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32960 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32961 }
32962 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
32963 return (void *)((wxLog *) ((wxLogBuffer *) x));
32964 }
32965 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32966 return (void *)((wxLog *) ((wxLogStderr *) x));
32967 }
32968 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32969 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32970 }
32971 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32972 return (void *)((wxLog *) ((wxLogWindow *) x));
32973 }
32974 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32975 return (void *)((wxLog *) ((wxLogChain *) x));
32976 }
32977 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32978 return (void *)((wxLog *) ((wxLogGui *) x));
32979 }
32980 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32981 return (void *)((wxLog *) ((wxPyLog *) x));
32982 }
32983 static void *_p_wxControlTo_p_wxWindow(void *x) {
32984 return (void *)((wxWindow *) ((wxControl *) x));
32985 }
32986 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32987 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32988 }
32989 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32990 return (void *)((wxWindow *) ((wxMenuBar *) x));
32991 }
32992 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32993 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32994 }
32995 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32996 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32997 }
32998 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}};
32999 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}};
33000 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33001 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}};
33002 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogBuffer", _p_wxLogBufferTo_p_wxLog, 0, 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}};
33003 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}};
33004 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}};
33005 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}};
33006 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}};
33007 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}};
33008 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}};
33009 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}};
33010 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}};
33011 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}};
33012 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}};
33013 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}};
33014 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}};
33015 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}};
33016 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0, 0, 0, 0},{"_p_void", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33017 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}};
33018 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}};
33019 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}};
33020 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}};
33021 static swig_type_info _swigt__p_wxDC[] = {{"_p_wxDC", 0, "wxDC *", 0, 0, 0, 0},{"_p_wxDC", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33022 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}};
33023 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}};
33024 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}};
33025 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}};
33026 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}};
33027 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}};
33028 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}};
33029 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}};
33030 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}};
33031 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}};
33032 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}};
33033 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}};
33034 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}};
33035 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}};
33036 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}};
33037 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}};
33038 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}};
33039 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}};
33040 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}};
33041 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}};
33042 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}};
33043 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}};
33044 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}};
33045 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}};
33046 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}};
33047 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}};
33048 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}};
33049 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}};
33050 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}};
33051 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}};
33052 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}};
33053 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}};
33054 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}};
33055 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}};
33056 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}};
33057 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}};
33058 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}};
33059 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}};
33060 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}};
33061 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}};
33062 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}};
33063 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}};
33064 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}};
33065 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}};
33066 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}};
33067 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}};
33068 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}};
33069 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}};
33070 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}};
33071 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}};
33072 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}};
33073 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}};
33074 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}};
33075 static swig_type_info _swigt__p_wxLogBuffer[] = {{"_p_wxLogBuffer", 0, "wxLogBuffer *", 0, 0, 0, 0},{"_p_wxLogBuffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
33076 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}};
33077 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}};
33078 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}};
33079 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}};
33080 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}};
33081 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}};
33082 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}};
33083 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}};
33084 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}};
33085 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}};
33086 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}};
33087 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}};
33088 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}};
33089 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}};
33090 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}};
33091 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}};
33092 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}};
33093 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}};
33094 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}};
33095 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}};
33096 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}};
33097
33098 static swig_type_info *swig_types_initial[] = {
33099 _swigt__p_wxLogChain,
33100 _swigt__p_wxMutexGuiLocker,
33101 _swigt__p_wxMetafile,
33102 _swigt__p_wxFileHistory,
33103 _swigt__p_wxLog,
33104 _swigt__p_wxMenu,
33105 _swigt__p_wxEvent,
33106 _swigt__p_wxDateTime__TimeZone,
33107 _swigt__p_wxConfigBase,
33108 _swigt__p_wxDisplay,
33109 _swigt__p_wxFileType,
33110 _swigt__p_wxLogGui,
33111 _swigt__p_wxFont,
33112 _swigt__p_wxDataFormat,
33113 _swigt__p_wxTimerEvent,
33114 _swigt__p_wxCaret,
33115 _swigt__ptrdiff_t,
33116 _swigt__std__ptrdiff_t,
33117 _swigt__p_void,
33118 _swigt__p_int,
33119 _swigt__p_wxSize,
33120 _swigt__p_wxClipboard,
33121 _swigt__p_wxStopWatch,
33122 _swigt__p_wxDC,
33123 _swigt__p_wxClipboardLocker,
33124 _swigt__p_wxIcon,
33125 _swigt__p_wxLogStderr,
33126 _swigt__p_wxLogTextCtrl,
33127 _swigt__p_wxTextCtrl,
33128 _swigt__p_wxBusyCursor,
33129 _swigt__p_wxBitmapDataObject,
33130 _swigt__p_wxTextDataObject,
33131 _swigt__p_wxDataObject,
33132 _swigt__p_wxPyTextDataObject,
33133 _swigt__p_wxPyBitmapDataObject,
33134 _swigt__p_wxFileDataObject,
33135 _swigt__p_wxCustomDataObject,
33136 _swigt__p_wxURLDataObject,
33137 _swigt__p_wxMetafileDataObject,
33138 _swigt__p_wxSound,
33139 _swigt__p_wxTimerRunner,
33140 _swigt__p_wxLogWindow,
33141 _swigt__p_wxTimeSpan,
33142 _swigt__p_wxArrayString,
33143 _swigt__p_wxWindowDisabler,
33144 _swigt__p_form_ops_t,
33145 _swigt__p_wxToolTip,
33146 _swigt__p_wxDataObjectComposite,
33147 _swigt__p_wxSystemSettings,
33148 _swigt__p_wxFileConfig,
33149 _swigt__p_wxVideoMode,
33150 _swigt__p_wxDataObjectSimple,
33151 _swigt__p_wxPyDataObjectSimple,
33152 _swigt__p_wxDuplexMode,
33153 _swigt__p_wxEvtHandler,
33154 _swigt__p_wxRect,
33155 _swigt__p_char,
33156 _swigt__p_wxSingleInstanceChecker,
33157 _swigt__p_wxStandardPaths,
33158 _swigt__p_wxFileTypeInfo,
33159 _swigt__p_wxFrame,
33160 _swigt__p_wxTimer,
33161 _swigt__p_wxPaperSize,
33162 _swigt__p_wxMimeTypesManager,
33163 _swigt__p_wxPyArtProvider,
33164 _swigt__p_wxPyTipProvider,
33165 _swigt__p_wxTipProvider,
33166 _swigt__p_wxJoystick,
33167 _swigt__p_wxSystemOptions,
33168 _swigt__p_wxPoint,
33169 _swigt__p_wxJoystickEvent,
33170 _swigt__p_wxCursor,
33171 _swigt__p_wxObject,
33172 _swigt__p_wxOutputStream,
33173 _swigt__p_wxDateTime,
33174 _swigt__p_wxPyDropSource,
33175 _swigt__p_unsigned_long,
33176 _swigt__p_wxLogBuffer,
33177 _swigt__p_wxKillError,
33178 _swigt__p_wxWindow,
33179 _swigt__p_wxString,
33180 _swigt__p_wxPyProcess,
33181 _swigt__p_wxBitmap,
33182 _swigt__unsigned_int,
33183 _swigt__p_unsigned_int,
33184 _swigt__p_wxConfig,
33185 _swigt__p_unsigned_char,
33186 _swigt__p_wxChar,
33187 _swigt__p_wxBusyInfo,
33188 _swigt__p_wxPyDropTarget,
33189 _swigt__p_wxPyTextDropTarget,
33190 _swigt__p_wxPyFileDropTarget,
33191 _swigt__p_wxProcessEvent,
33192 _swigt__p_wxPyLog,
33193 _swigt__p_wxLogNull,
33194 _swigt__p_wxColour,
33195 _swigt__p_wxPyTimer,
33196 _swigt__p_wxConfigPathChanger,
33197 _swigt__p_wxDateSpan,
33198 0
33199 };
33200
33201
33202 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
33203
33204 static swig_const_info swig_const_table[] = {
33205 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
33206 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
33207 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
33208 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
33209 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
33210 {0, 0, 0, 0.0, 0, 0}};
33211
33212 #ifdef __cplusplus
33213 }
33214 #endif
33215
33216
33217 #ifdef __cplusplus
33218 extern "C" {
33219 #endif
33220
33221 /* Python-specific SWIG API */
33222 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33223 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33224 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33225
33226 /* -----------------------------------------------------------------------------
33227 * global variable support code.
33228 * ----------------------------------------------------------------------------- */
33229
33230 typedef struct swig_globalvar {
33231 char *name; /* Name of global variable */
33232 PyObject *(*get_attr)(); /* Return the current value */
33233 int (*set_attr)(PyObject *); /* Set the value */
33234 struct swig_globalvar *next;
33235 } swig_globalvar;
33236
33237 typedef struct swig_varlinkobject {
33238 PyObject_HEAD
33239 swig_globalvar *vars;
33240 } swig_varlinkobject;
33241
33242 static PyObject *
33243 swig_varlink_repr(swig_varlinkobject *v) {
33244 v = v;
33245 return PyString_FromString("<Swig global variables>");
33246 }
33247
33248 static int
33249 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33250 swig_globalvar *var;
33251 flags = flags;
33252 fprintf(fp,"Swig global variables { ");
33253 for (var = v->vars; var; var=var->next) {
33254 fprintf(fp,"%s", var->name);
33255 if (var->next) fprintf(fp,", ");
33256 }
33257 fprintf(fp," }\n");
33258 return 0;
33259 }
33260
33261 static PyObject *
33262 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33263 swig_globalvar *var = v->vars;
33264 while (var) {
33265 if (strcmp(var->name,n) == 0) {
33266 return (*var->get_attr)();
33267 }
33268 var = var->next;
33269 }
33270 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33271 return NULL;
33272 }
33273
33274 static int
33275 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33276 swig_globalvar *var = v->vars;
33277 while (var) {
33278 if (strcmp(var->name,n) == 0) {
33279 return (*var->set_attr)(p);
33280 }
33281 var = var->next;
33282 }
33283 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33284 return 1;
33285 }
33286
33287 static PyTypeObject varlinktype = {
33288 PyObject_HEAD_INIT(0)
33289 0, /* Number of items in variable part (ob_size) */
33290 (char *)"swigvarlink", /* Type name (tp_name) */
33291 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33292 0, /* Itemsize (tp_itemsize) */
33293 0, /* Deallocator (tp_dealloc) */
33294 (printfunc) swig_varlink_print, /* Print (tp_print) */
33295 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33296 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33297 0, /* tp_compare */
33298 (reprfunc) swig_varlink_repr, /* tp_repr */
33299 0, /* tp_as_number */
33300 0, /* tp_as_sequence */
33301 0, /* tp_as_mapping */
33302 0, /* tp_hash */
33303 0, /* tp_call */
33304 0, /* tp_str */
33305 0, /* tp_getattro */
33306 0, /* tp_setattro */
33307 0, /* tp_as_buffer */
33308 0, /* tp_flags */
33309 0, /* tp_doc */
33310 #if PY_VERSION_HEX >= 0x02000000
33311 0, /* tp_traverse */
33312 0, /* tp_clear */
33313 #endif
33314 #if PY_VERSION_HEX >= 0x02010000
33315 0, /* tp_richcompare */
33316 0, /* tp_weaklistoffset */
33317 #endif
33318 #if PY_VERSION_HEX >= 0x02020000
33319 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33320 #endif
33321 #if PY_VERSION_HEX >= 0x02030000
33322 0, /* tp_del */
33323 #endif
33324 #ifdef COUNT_ALLOCS
33325 0,0,0,0 /* tp_alloc -> tp_next */
33326 #endif
33327 };
33328
33329 /* Create a variable linking object for use later */
33330 static PyObject *
33331 SWIG_Python_newvarlink(void) {
33332 swig_varlinkobject *result = 0;
33333 result = PyMem_NEW(swig_varlinkobject,1);
33334 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33335 result->ob_type = &varlinktype;
33336 result->vars = 0;
33337 result->ob_refcnt = 0;
33338 Py_XINCREF((PyObject *) result);
33339 return ((PyObject*) result);
33340 }
33341
33342 static void
33343 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33344 swig_varlinkobject *v;
33345 swig_globalvar *gv;
33346 v= (swig_varlinkobject *) p;
33347 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33348 gv->name = (char *) malloc(strlen(name)+1);
33349 strcpy(gv->name,name);
33350 gv->get_attr = get_attr;
33351 gv->set_attr = set_attr;
33352 gv->next = v->vars;
33353 v->vars = gv;
33354 }
33355
33356 /* -----------------------------------------------------------------------------
33357 * constants/methods manipulation
33358 * ----------------------------------------------------------------------------- */
33359
33360 /* Install Constants */
33361 static void
33362 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33363 PyObject *obj = 0;
33364 size_t i;
33365 for (i = 0; constants[i].type; i++) {
33366 switch(constants[i].type) {
33367 case SWIG_PY_INT:
33368 obj = PyInt_FromLong(constants[i].lvalue);
33369 break;
33370 case SWIG_PY_FLOAT:
33371 obj = PyFloat_FromDouble(constants[i].dvalue);
33372 break;
33373 case SWIG_PY_STRING:
33374 if (constants[i].pvalue) {
33375 obj = PyString_FromString((char *) constants[i].pvalue);
33376 } else {
33377 Py_INCREF(Py_None);
33378 obj = Py_None;
33379 }
33380 break;
33381 case SWIG_PY_POINTER:
33382 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33383 break;
33384 case SWIG_PY_BINARY:
33385 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33386 break;
33387 default:
33388 obj = 0;
33389 break;
33390 }
33391 if (obj) {
33392 PyDict_SetItemString(d,constants[i].name,obj);
33393 Py_DECREF(obj);
33394 }
33395 }
33396 }
33397
33398 /* -----------------------------------------------------------------------------*/
33399 /* Fix SwigMethods to carry the callback ptrs when needed */
33400 /* -----------------------------------------------------------------------------*/
33401
33402 static void
33403 SWIG_Python_FixMethods(PyMethodDef *methods,
33404 swig_const_info *const_table,
33405 swig_type_info **types,
33406 swig_type_info **types_initial) {
33407 size_t i;
33408 for (i = 0; methods[i].ml_name; ++i) {
33409 char *c = methods[i].ml_doc;
33410 if (c && (c = strstr(c, "swig_ptr: "))) {
33411 int j;
33412 swig_const_info *ci = 0;
33413 char *name = c + 10;
33414 for (j = 0; const_table[j].type; j++) {
33415 if (strncmp(const_table[j].name, name,
33416 strlen(const_table[j].name)) == 0) {
33417 ci = &(const_table[j]);
33418 break;
33419 }
33420 }
33421 if (ci) {
33422 size_t shift = (ci->ptype) - types;
33423 swig_type_info *ty = types_initial[shift];
33424 size_t ldoc = (c - methods[i].ml_doc);
33425 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33426 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33427 char *buff = ndoc;
33428 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33429 strncpy(buff, methods[i].ml_doc, ldoc);
33430 buff += ldoc;
33431 strncpy(buff, "swig_ptr: ", 10);
33432 buff += 10;
33433 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33434 methods[i].ml_doc = ndoc;
33435 }
33436 }
33437 }
33438 }
33439
33440 /* -----------------------------------------------------------------------------*
33441 * Initialize type list
33442 * -----------------------------------------------------------------------------*/
33443
33444 #if PY_MAJOR_VERSION < 2
33445 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33446 is copied out of Python/modsupport.c in python version 2.3.4 */
33447 static int
33448 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33449 {
33450 PyObject *dict;
33451 if (!PyModule_Check(m)) {
33452 PyErr_SetString(PyExc_TypeError,
33453 "PyModule_AddObject() needs module as first arg");
33454 return -1;
33455 }
33456 if (!o) {
33457 PyErr_SetString(PyExc_TypeError,
33458 "PyModule_AddObject() needs non-NULL value");
33459 return -1;
33460 }
33461
33462 dict = PyModule_GetDict(m);
33463 if (dict == NULL) {
33464 /* Internal error -- modules must have a dict! */
33465 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33466 PyModule_GetName(m));
33467 return -1;
33468 }
33469 if (PyDict_SetItemString(dict, name, o))
33470 return -1;
33471 Py_DECREF(o);
33472 return 0;
33473 }
33474 #endif
33475
33476 static swig_type_info **
33477 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33478 static PyMethodDef swig_empty_runtime_method_table[] = {
33479 {
33480 NULL, NULL, 0, NULL
33481 }
33482 };/* Sentinel */
33483
33484 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33485 swig_empty_runtime_method_table);
33486 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33487 if (pointer && module) {
33488 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33489 }
33490 return type_list_handle;
33491 }
33492
33493 static swig_type_info **
33494 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33495 swig_type_info **type_pointer;
33496
33497 /* first check if module already created */
33498 type_pointer = SWIG_Python_GetTypeListHandle();
33499 if (type_pointer) {
33500 return type_pointer;
33501 } else {
33502 /* create a new module and variable */
33503 return SWIG_Python_SetTypeListHandle(type_list_handle);
33504 }
33505 }
33506
33507 #ifdef __cplusplus
33508 }
33509 #endif
33510
33511 /* -----------------------------------------------------------------------------*
33512 * Partial Init method
33513 * -----------------------------------------------------------------------------*/
33514
33515 #ifdef SWIG_LINK_RUNTIME
33516 #ifdef __cplusplus
33517 extern "C"
33518 #endif
33519 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33520 #endif
33521
33522 #ifdef __cplusplus
33523 extern "C"
33524 #endif
33525 SWIGEXPORT(void) SWIG_init(void) {
33526 static PyObject *SWIG_globals = 0;
33527 static int typeinit = 0;
33528 PyObject *m, *d;
33529 int i;
33530 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33531
33532 /* Fix SwigMethods to carry the callback ptrs when needed */
33533 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33534
33535 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33536 d = PyModule_GetDict(m);
33537
33538 if (!typeinit) {
33539 #ifdef SWIG_LINK_RUNTIME
33540 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33541 #else
33542 # ifndef SWIG_STATIC_RUNTIME
33543 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33544 # endif
33545 #endif
33546 for (i = 0; swig_types_initial[i]; i++) {
33547 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33548 }
33549 typeinit = 1;
33550 }
33551 SWIG_InstallConstants(d,swig_const_table);
33552
33553 {
33554 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33825 }
33826 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33827 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33828 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33829 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33830 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33831 {
33832 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33842 }
33843 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33844
33845 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33846
33847 {
33848 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33879 }
33880 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33881 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33882 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33883 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33884 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33885 {
33886 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33977 }
33978 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33979 {
33980 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33993 }
33994
33995 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33996
33997 {
33998 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
34017 }
34018 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
34019 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
34020 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
34021 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
34022 {
34023 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
34045 }
34046 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
34047 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
34048 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
34049 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
34050 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
34051 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
34052 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
34053 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
34054 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
34055 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
34056 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
34057 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
34058 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
34059 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
34060 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
34061 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
34062 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
34063 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
34064 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
34065 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
34066 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
34067 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
34068 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
34069 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
34070 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
34071 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
34072 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
34073 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
34074 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
34075 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
34076 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
34077 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
34078 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
34079 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
34080 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
34081 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
34082 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
34083 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
34084 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
34085 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
34086 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
34087 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
34088 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
34089 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
34090 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
34091 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
34092 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
34093 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
34094 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
34095 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
34096 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
34097 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
34098 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
34099 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
34100 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
34101 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
34102 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
34103
34104 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
34105
34106 {
34107 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
34132 }
34133 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
34134 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
34135 {
34136 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34395 }
34396 {
34397 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34398 }
34399 {
34400 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34401 }
34402 {
34403 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34404 }
34405 {
34406 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34407 }
34408 {
34409 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34410 }
34411 {
34412 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34413 }
34414 {
34415 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34416 }
34417 {
34418 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34419 }
34420 {
34421 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34422 }
34423 {
34424 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34425 }
34426 {
34427 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34428 }
34429 {
34430 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34431 }
34432 {
34433 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34434 }
34435 {
34436 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34437 }
34438 {
34439 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34440 }
34441 {
34442 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34443 }
34444 {
34445 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34446 }
34447 {
34448 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34449 }
34450 {
34451 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34452 }
34453 {
34454 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34455 }
34456 {
34457 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34458 }
34459 {
34460 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34461 }
34462 {
34463 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34464 }
34465 {
34466 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34467 }
34468 {
34469 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34470 }
34471 {
34472 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34473 }
34474 {
34475 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34476 }
34477 {
34478 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34479 }
34480 {
34481 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34482 }
34483 {
34484 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34485 }
34486 {
34487 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34488 }
34489 {
34490 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34491 }
34492 {
34493 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34494 }
34495 {
34496 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34497 }
34498 {
34499 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34500 }
34501 {
34502 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34503 }
34504 {
34505 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34506 }
34507 {
34508 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34509 }
34510 {
34511 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34512 }
34513 {
34514 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34515 }
34516 {
34517 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34518 }
34519 {
34520 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34521 }
34522 {
34523 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34524 }
34525 {
34526 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34527 }
34528 {
34529 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34530 }
34531 {
34532 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34533 }
34534 {
34535 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34536 }
34537 {
34538 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34539 }
34540 {
34541 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34542 }
34543 {
34544 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34545 }
34546 {
34547 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34548 }
34549 {
34550 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34551 }
34552 {
34553 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34554 }
34555 {
34556 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34557 }
34558 {
34559 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34560 }
34561 {
34562 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34563 }
34564 {
34565 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34566 }
34567 {
34568 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34569 }
34570 {
34571 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34572 }
34573 {
34574 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34575 }
34576 {
34577 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34578 }
34579 {
34580 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34581 }
34582 {
34583 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34584 }
34585 {
34586 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34587 }
34588 {
34589 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34590 }
34591 {
34592 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34593 }
34594 {
34595 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34596 }
34597 {
34598 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34599 }
34600 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34601 {
34602 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34603 }
34604 {
34605 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34606 }
34607 {
34608 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34609 }
34610 {
34611 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34612 }
34613 {
34614 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34615 }
34616 {
34617 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34618 }
34619 {
34620 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34621 }
34622 {
34623 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34624 }
34625 {
34626 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34627 }
34628 {
34629 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34630 }
34631 {
34632 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34633 }
34634 {
34635 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34636 }
34637 {
34638 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34639 }
34640 {
34641 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34642 }
34643 {
34644 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34645 }
34646 {
34647 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34648 }
34649 {
34650 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34651 }
34652 {
34653 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34654 }
34655 {
34656 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34657 }
34658 {
34659 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34660 }
34661 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34662 {
34663 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34664 }
34665 {
34666 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34667 }
34668 {
34669 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34670 }
34671 {
34672 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34673 }
34674 {
34675 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34676 }
34677 {
34678 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34679 }
34680 {
34681 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34682 }
34683 {
34684 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34685 }
34686 {
34687 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34688 }
34689 {
34690 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34691 }
34692 {
34693 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34694 }
34695 {
34696 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34697 }
34698
34699 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34700 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34701 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34702 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34703
34704 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34705 }
34706
wxWidgets (Impactor)