]> 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
return name and extension by const ref, not by value, to prevent bugs as the one...
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 bool blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 bool blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 bool blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 bool blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 bool blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 bool blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 bool blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 bool blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260
2261
2262 // Make a tuple and put the values in it
2263 bool blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 bool blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 bool blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518 static PyObject *DateTime_GetAmPmStrings(){
2519 wxString am;
2520 wxString pm;
2521 wxDateTime::GetAmPmStrings(&am, &pm);
2522 bool blocked = wxPyBeginBlockThreads();
2523 PyObject* tup = PyTuple_New(2);
2524 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2525 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2526 wxPyEndBlockThreads(blocked);
2527 return tup;
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2541 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2542 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2543 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2545 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2546 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2547 return (*self < *other);
2548 }
2549 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2550 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2551 return (*self <= *other);
2552 }
2553 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2554 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2555 return (*self > *other);
2556 }
2557 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2559 return (*self >= *other);
2560 }
2561 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2563 return (*self == *other);
2564 }
2565 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2567 return (*self != *other);
2568 }
2569 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2570 const wxChar* rv;
2571 const wxChar* _date = date;
2572 rv = self->ParseRfc822Date(_date);
2573 if (rv == NULL) return -1;
2574 return rv - _date;
2575 }
2576 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseFormat(_date, format, dateDef);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2584 const wxChar* rv;
2585 const wxChar* _datetime = datetime;
2586 rv = self->ParseDateTime(_datetime);
2587 if (rv == NULL) return -1;
2588 return rv - _datetime;
2589 }
2590 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseDate(_date);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2598 const wxChar* rv;
2599 const wxChar* _time = time;
2600 rv = self->ParseTime(_time);
2601 if (rv == NULL) return -1;
2602 return rv - _time;
2603 }
2604 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2605 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2606 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2607 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2608 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2609 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2610 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2611 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2612 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2613 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2614 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2615 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2616 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2617 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2618 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2620
2621 #include <wx/dataobj.h>
2622
2623 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2624 size_t count = self->GetFormatCount(dir);
2625 wxDataFormat* formats = new wxDataFormat[count];
2626 self->GetAllFormats(formats, dir);
2627
2628 bool blocked = wxPyBeginBlockThreads();
2629 PyObject* list = PyList_New(count);
2630 for (size_t i=0; i<count; i++) {
2631 wxDataFormat* format = new wxDataFormat(formats[i]);
2632 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2633 PyList_Append(list, obj);
2634 Py_DECREF(obj);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 delete [] formats;
2638 return list;
2639 }
2640 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2641 PyObject* rval = NULL;
2642 size_t size = self->GetDataSize(format);
2643 bool blocked = wxPyBeginBlockThreads();
2644 if (size) {
2645 char* buf = new char[size];
2646 if (self->GetDataHere(format, buf))
2647 rval = PyString_FromStringAndSize(buf, size);
2648 delete [] buf;
2649 }
2650 if (! rval) {
2651 rval = Py_None;
2652 Py_INCREF(rval);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return rval;
2656 }
2657 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2658 bool rval;
2659 bool blocked = wxPyBeginBlockThreads();
2660 if (PyString_Check(data)) {
2661 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2662 }
2663 else {
2664 // raise a TypeError if not a string
2665 PyErr_SetString(PyExc_TypeError, "String expected.");
2666 rval = false;
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2672 PyObject* rval = NULL;
2673 size_t size = self->GetDataSize();
2674 bool blocked = wxPyBeginBlockThreads();
2675 if (size) {
2676 char* buf = new char[size];
2677 if (self->GetDataHere(buf))
2678 rval = PyString_FromStringAndSize(buf, size);
2679 delete [] buf;
2680 }
2681 if (! rval) {
2682 rval = Py_None;
2683 Py_INCREF(rval);
2684 }
2685 wxPyEndBlockThreads(blocked);
2686 return rval;
2687 }
2688 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2689 bool rval;
2690 bool blocked = wxPyBeginBlockThreads();
2691 if (PyString_Check(data)) {
2692 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2693 }
2694 else {
2695 // raise a TypeError if not a string
2696 PyErr_SetString(PyExc_TypeError, "String expected.");
2697 rval = false;
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 // Create a new class for wxPython to use
2703 class wxPyDataObjectSimple : public wxDataObjectSimple {
2704 public:
2705 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2706 : wxDataObjectSimple(format) {}
2707
2708 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2709 bool GetDataHere(void *buf) const;
2710 bool SetData(size_t len, const void *buf) const;
2711 PYPRIVATE;
2712 };
2713
2714 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2715
2716 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2717 // We need to get the data for this object and write it to buf. I think
2718 // the best way to do this for wxPython is to have the Python method
2719 // return either a string or None and then act appropriately with the
2720 // C++ version.
2721
2722 bool rval = false;
2723 bool blocked = wxPyBeginBlockThreads();
2724 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2725 PyObject* ro;
2726 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2727 if (ro) {
2728 rval = (ro != Py_None && PyString_Check(ro));
2729 if (rval)
2730 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2731 Py_DECREF(ro);
2732 }
2733 }
2734 wxPyEndBlockThreads(blocked);
2735 return rval;
2736 }
2737
2738 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2739 // For this one we simply need to make a string from buf and len
2740 // and send it to the Python method.
2741 bool rval = false;
2742 bool blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2744 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2746 Py_DECREF(data);
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 // Create a new class for wxPython to use
2753 class wxPyTextDataObject : public wxTextDataObject {
2754 public:
2755 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2756 : wxTextDataObject(text) {}
2757
2758 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2759 DEC_PYCALLBACK_STRING__const(GetText);
2760 DEC_PYCALLBACK__STRING(SetText);
2761 PYPRIVATE;
2762 };
2763
2764 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2765 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2766 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2767
2768
2769 // Create a new class for wxPython to use
2770 class wxPyBitmapDataObject : public wxBitmapDataObject {
2771 public:
2772 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2773 : wxBitmapDataObject(bitmap) {}
2774
2775 wxBitmap GetBitmap() const;
2776 void SetBitmap(const wxBitmap& bitmap);
2777 PYPRIVATE;
2778 };
2779
2780 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2781 wxBitmap* rval = &wxNullBitmap;
2782 bool blocked = wxPyBeginBlockThreads();
2783 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2784 PyObject* ro;
2785 wxBitmap* ptr;
2786 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2787 if (ro) {
2788 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2789 rval = ptr;
2790 Py_DECREF(ro);
2791 }
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 return *rval;
2795 }
2796
2797 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2798 bool blocked = wxPyBeginBlockThreads();
2799 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2800 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2801 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2802 Py_DECREF(bo);
2803 }
2804 wxPyEndBlockThreads(blocked);
2805 }
2806
2807 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2808 return new wxCustomDataObject(wxDataFormat(formatName));
2809 }
2810 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2811 bool rval;
2812 bool blocked = wxPyBeginBlockThreads();
2813 if (PyString_Check(data)) {
2814 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2815 }
2816 else {
2817 // raise a TypeError if not a string
2818 PyErr_SetString(PyExc_TypeError, "String expected.");
2819 rval = false;
2820 }
2821 wxPyEndBlockThreads(blocked);
2822 return rval;
2823 }
2824 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2825 PyObject* obj;
2826 bool blocked = wxPyBeginBlockThreads();
2827 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2828 wxPyEndBlockThreads(blocked);
2829 return obj;
2830 }
2831
2832 #include <wx/metafile.h>
2833
2834
2835 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2836
2837
2838 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2841 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2842 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2843
2844
2845 class wxPyTextDropTarget : public wxTextDropTarget {
2846 public:
2847 wxPyTextDropTarget() {}
2848
2849 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2850
2851 DEC_PYCALLBACK__(OnLeave);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2855 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2856
2857 PYPRIVATE;
2858 };
2859
2860 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2861 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2866
2867
2868
2869 class wxPyFileDropTarget : public wxFileDropTarget {
2870 public:
2871 wxPyFileDropTarget() {}
2872
2873 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2885 const wxArrayString& filenames) {
2886 bool rval = false;
2887 bool blocked = wxPyBeginBlockThreads();
2888 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2889 PyObject* list = wxArrayString2PyList_helper(filenames);
2890 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2891 Py_DECREF(list);
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896
2897
2898
2899 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2903 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2904
2905
2906
2907
2908 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2909
2910 #include <wx/display.h>
2911
2912 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2913 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2914
2915 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2916 #if !wxUSE_DISPLAY
2917 #include <wx/dynarray.h>
2918 #include <wx/vidmode.h>
2919
2920 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2921 #include "wx/arrimpl.cpp"
2922 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2923 const wxVideoMode wxDefaultVideoMode;
2924
2925 class wxDisplay
2926 {
2927 public:
2928 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2929 ~wxDisplay() {}
2930
2931 static size_t GetCount()
2932 { wxPyRaiseNotImplemented(); return 0; }
2933
2934 static int GetFromPoint(const wxPoint& pt)
2935 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2936 static int GetFromWindow(wxWindow *window)
2937 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2938
2939 virtual bool IsOk() const { return false; }
2940 virtual wxRect GetGeometry() const { wxRect r; return r; }
2941 virtual wxString GetName() const { return wxEmptyString; }
2942 bool IsPrimary() const { return false; }
2943
2944 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2945 { wxArrayVideoModes a; return a; }
2946
2947 virtual wxVideoMode GetCurrentMode() const
2948 { return wxDefaultVideoMode; }
2949
2950 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2951 { return false; }
2952
2953 void ResetMode() {}
2954 };
2955 #endif
2956
2957 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2958 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2959 PyObject* pyList = NULL;
2960 wxArrayVideoModes arr = self->GetModes(mode);
2961 bool blocked = wxPyBeginBlockThreads();
2962 pyList = PyList_New(0);
2963 for (int i=0; i < arr.GetCount(); i++) {
2964 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2965 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2966 PyList_Append(pyList, pyObj);
2967 Py_DECREF(pyObj);
2968 }
2969 wxPyEndBlockThreads(blocked);
2970 return pyList;
2971 }
2972
2973 #include <wx/stdpaths.h>
2974
2975 static wxStandardPaths *StandardPaths_Get(){
2976 return (wxStandardPaths*) &wxStandardPaths::Get();
2977 }
2978 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2979 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2980 #ifdef __cplusplus
2981 extern "C" {
2982 #endif
2983 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2984 PyObject *resultobj;
2985 wxSystemColour arg1 ;
2986 wxColour result;
2987 PyObject * obj0 = 0 ;
2988 char *kwnames[] = {
2989 (char *) "index", NULL
2990 };
2991
2992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2993 {
2994 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2995 if (SWIG_arg_fail(1)) SWIG_fail;
2996 }
2997 {
2998 if (!wxPyCheckForApp()) SWIG_fail;
2999 PyThreadState* __tstate = wxPyBeginAllowThreads();
3000 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3001
3002 wxPyEndAllowThreads(__tstate);
3003 if (PyErr_Occurred()) SWIG_fail;
3004 }
3005 {
3006 wxColour * resultptr;
3007 resultptr = new wxColour((wxColour &)(result));
3008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3009 }
3010 return resultobj;
3011 fail:
3012 return NULL;
3013 }
3014
3015
3016 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3017 PyObject *resultobj;
3018 wxSystemFont arg1 ;
3019 wxFont result;
3020 PyObject * obj0 = 0 ;
3021 char *kwnames[] = {
3022 (char *) "index", NULL
3023 };
3024
3025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3026 {
3027 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3028 if (SWIG_arg_fail(1)) SWIG_fail;
3029 }
3030 {
3031 if (!wxPyCheckForApp()) SWIG_fail;
3032 PyThreadState* __tstate = wxPyBeginAllowThreads();
3033 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3034
3035 wxPyEndAllowThreads(__tstate);
3036 if (PyErr_Occurred()) SWIG_fail;
3037 }
3038 {
3039 wxFont * resultptr;
3040 resultptr = new wxFont((wxFont &)(result));
3041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3042 }
3043 return resultobj;
3044 fail:
3045 return NULL;
3046 }
3047
3048
3049 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3050 PyObject *resultobj;
3051 wxSystemMetric arg1 ;
3052 int result;
3053 PyObject * obj0 = 0 ;
3054 char *kwnames[] = {
3055 (char *) "index", NULL
3056 };
3057
3058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3059 {
3060 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3061 if (SWIG_arg_fail(1)) SWIG_fail;
3062 }
3063 {
3064 if (!wxPyCheckForApp()) SWIG_fail;
3065 PyThreadState* __tstate = wxPyBeginAllowThreads();
3066 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3067
3068 wxPyEndAllowThreads(__tstate);
3069 if (PyErr_Occurred()) SWIG_fail;
3070 }
3071 {
3072 resultobj = SWIG_From_int((int)(result));
3073 }
3074 return resultobj;
3075 fail:
3076 return NULL;
3077 }
3078
3079
3080 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3081 PyObject *resultobj;
3082 wxSystemFeature arg1 ;
3083 bool result;
3084 PyObject * obj0 = 0 ;
3085 char *kwnames[] = {
3086 (char *) "index", NULL
3087 };
3088
3089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3090 {
3091 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3092 if (SWIG_arg_fail(1)) SWIG_fail;
3093 }
3094 {
3095 if (!wxPyCheckForApp()) SWIG_fail;
3096 PyThreadState* __tstate = wxPyBeginAllowThreads();
3097 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3098
3099 wxPyEndAllowThreads(__tstate);
3100 if (PyErr_Occurred()) SWIG_fail;
3101 }
3102 {
3103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3104 }
3105 return resultobj;
3106 fail:
3107 return NULL;
3108 }
3109
3110
3111 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3112 PyObject *resultobj;
3113 wxSystemScreenType result;
3114 char *kwnames[] = {
3115 NULL
3116 };
3117
3118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3119 {
3120 if (!wxPyCheckForApp()) SWIG_fail;
3121 PyThreadState* __tstate = wxPyBeginAllowThreads();
3122 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3123
3124 wxPyEndAllowThreads(__tstate);
3125 if (PyErr_Occurred()) SWIG_fail;
3126 }
3127 resultobj = SWIG_From_int((result));
3128 return resultobj;
3129 fail:
3130 return NULL;
3131 }
3132
3133
3134 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3135 PyObject *resultobj;
3136 wxSystemScreenType arg1 ;
3137 PyObject * obj0 = 0 ;
3138 char *kwnames[] = {
3139 (char *) "screen", NULL
3140 };
3141
3142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3143 {
3144 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3145 if (SWIG_arg_fail(1)) SWIG_fail;
3146 }
3147 {
3148 if (!wxPyCheckForApp()) SWIG_fail;
3149 PyThreadState* __tstate = wxPyBeginAllowThreads();
3150 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3151
3152 wxPyEndAllowThreads(__tstate);
3153 if (PyErr_Occurred()) SWIG_fail;
3154 }
3155 Py_INCREF(Py_None); resultobj = Py_None;
3156 return resultobj;
3157 fail:
3158 return NULL;
3159 }
3160
3161
3162 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3163 PyObject *obj;
3164 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3165 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3166 Py_INCREF(obj);
3167 return Py_BuildValue((char *)"");
3168 }
3169 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3170 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3171 return 1;
3172 }
3173
3174
3175 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3176 PyObject *pyobj;
3177
3178 {
3179 #if wxUSE_UNICODE
3180 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3181 #else
3182 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3183 #endif
3184 }
3185 return pyobj;
3186 }
3187
3188
3189 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3190 PyObject *resultobj;
3191 wxSystemOptions *result;
3192 char *kwnames[] = {
3193 NULL
3194 };
3195
3196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3197 {
3198 PyThreadState* __tstate = wxPyBeginAllowThreads();
3199 result = (wxSystemOptions *)new wxSystemOptions();
3200
3201 wxPyEndAllowThreads(__tstate);
3202 if (PyErr_Occurred()) SWIG_fail;
3203 }
3204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3205 return resultobj;
3206 fail:
3207 return NULL;
3208 }
3209
3210
3211 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3212 PyObject *resultobj;
3213 wxString *arg1 = 0 ;
3214 wxString *arg2 = 0 ;
3215 bool temp1 = false ;
3216 bool temp2 = false ;
3217 PyObject * obj0 = 0 ;
3218 PyObject * obj1 = 0 ;
3219 char *kwnames[] = {
3220 (char *) "name",(char *) "value", NULL
3221 };
3222
3223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3224 {
3225 arg1 = wxString_in_helper(obj0);
3226 if (arg1 == NULL) SWIG_fail;
3227 temp1 = true;
3228 }
3229 {
3230 arg2 = wxString_in_helper(obj1);
3231 if (arg2 == NULL) SWIG_fail;
3232 temp2 = true;
3233 }
3234 {
3235 PyThreadState* __tstate = wxPyBeginAllowThreads();
3236 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3237
3238 wxPyEndAllowThreads(__tstate);
3239 if (PyErr_Occurred()) SWIG_fail;
3240 }
3241 Py_INCREF(Py_None); resultobj = Py_None;
3242 {
3243 if (temp1)
3244 delete arg1;
3245 }
3246 {
3247 if (temp2)
3248 delete arg2;
3249 }
3250 return resultobj;
3251 fail:
3252 {
3253 if (temp1)
3254 delete arg1;
3255 }
3256 {
3257 if (temp2)
3258 delete arg2;
3259 }
3260 return NULL;
3261 }
3262
3263
3264 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3265 PyObject *resultobj;
3266 wxString *arg1 = 0 ;
3267 int arg2 ;
3268 bool temp1 = false ;
3269 PyObject * obj0 = 0 ;
3270 PyObject * obj1 = 0 ;
3271 char *kwnames[] = {
3272 (char *) "name",(char *) "value", NULL
3273 };
3274
3275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3276 {
3277 arg1 = wxString_in_helper(obj0);
3278 if (arg1 == NULL) SWIG_fail;
3279 temp1 = true;
3280 }
3281 {
3282 arg2 = (int)(SWIG_As_int(obj1));
3283 if (SWIG_arg_fail(2)) SWIG_fail;
3284 }
3285 {
3286 PyThreadState* __tstate = wxPyBeginAllowThreads();
3287 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3288
3289 wxPyEndAllowThreads(__tstate);
3290 if (PyErr_Occurred()) SWIG_fail;
3291 }
3292 Py_INCREF(Py_None); resultobj = Py_None;
3293 {
3294 if (temp1)
3295 delete arg1;
3296 }
3297 return resultobj;
3298 fail:
3299 {
3300 if (temp1)
3301 delete arg1;
3302 }
3303 return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3308 PyObject *resultobj;
3309 wxString *arg1 = 0 ;
3310 wxString result;
3311 bool temp1 = false ;
3312 PyObject * obj0 = 0 ;
3313 char *kwnames[] = {
3314 (char *) "name", NULL
3315 };
3316
3317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3318 {
3319 arg1 = wxString_in_helper(obj0);
3320 if (arg1 == NULL) SWIG_fail;
3321 temp1 = true;
3322 }
3323 {
3324 PyThreadState* __tstate = wxPyBeginAllowThreads();
3325 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3326
3327 wxPyEndAllowThreads(__tstate);
3328 if (PyErr_Occurred()) SWIG_fail;
3329 }
3330 {
3331 #if wxUSE_UNICODE
3332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3333 #else
3334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3335 #endif
3336 }
3337 {
3338 if (temp1)
3339 delete arg1;
3340 }
3341 return resultobj;
3342 fail:
3343 {
3344 if (temp1)
3345 delete arg1;
3346 }
3347 return NULL;
3348 }
3349
3350
3351 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3352 PyObject *resultobj;
3353 wxString *arg1 = 0 ;
3354 int result;
3355 bool temp1 = false ;
3356 PyObject * obj0 = 0 ;
3357 char *kwnames[] = {
3358 (char *) "name", NULL
3359 };
3360
3361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3362 {
3363 arg1 = wxString_in_helper(obj0);
3364 if (arg1 == NULL) SWIG_fail;
3365 temp1 = true;
3366 }
3367 {
3368 PyThreadState* __tstate = wxPyBeginAllowThreads();
3369 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3370
3371 wxPyEndAllowThreads(__tstate);
3372 if (PyErr_Occurred()) SWIG_fail;
3373 }
3374 {
3375 resultobj = SWIG_From_int((int)(result));
3376 }
3377 {
3378 if (temp1)
3379 delete arg1;
3380 }
3381 return resultobj;
3382 fail:
3383 {
3384 if (temp1)
3385 delete arg1;
3386 }
3387 return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3392 PyObject *resultobj;
3393 wxString *arg1 = 0 ;
3394 bool result;
3395 bool temp1 = false ;
3396 PyObject * obj0 = 0 ;
3397 char *kwnames[] = {
3398 (char *) "name", NULL
3399 };
3400
3401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3402 {
3403 arg1 = wxString_in_helper(obj0);
3404 if (arg1 == NULL) SWIG_fail;
3405 temp1 = true;
3406 }
3407 {
3408 PyThreadState* __tstate = wxPyBeginAllowThreads();
3409 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3410
3411 wxPyEndAllowThreads(__tstate);
3412 if (PyErr_Occurred()) SWIG_fail;
3413 }
3414 {
3415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3416 }
3417 {
3418 if (temp1)
3419 delete arg1;
3420 }
3421 return resultobj;
3422 fail:
3423 {
3424 if (temp1)
3425 delete arg1;
3426 }
3427 return NULL;
3428 }
3429
3430
3431 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3432 PyObject *obj;
3433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3434 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3435 Py_INCREF(obj);
3436 return Py_BuildValue((char *)"");
3437 }
3438 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3439 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3440 return 1;
3441 }
3442
3443
3444 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3445 PyObject *pyobj;
3446
3447 {
3448 #if wxUSE_UNICODE
3449 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3450 #else
3451 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3452 #endif
3453 }
3454 return pyobj;
3455 }
3456
3457
3458 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3459 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3460 return 1;
3461 }
3462
3463
3464 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3465 PyObject *pyobj;
3466
3467 {
3468 #if wxUSE_UNICODE
3469 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3470 #else
3471 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3472 #endif
3473 }
3474 return pyobj;
3475 }
3476
3477
3478 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3479 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3480 return 1;
3481 }
3482
3483
3484 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3485 PyObject *pyobj;
3486
3487 {
3488 #if wxUSE_UNICODE
3489 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3490 #else
3491 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3492 #endif
3493 }
3494 return pyobj;
3495 }
3496
3497
3498 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 long result;
3501 char *kwnames[] = {
3502 NULL
3503 };
3504
3505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3506 {
3507 PyThreadState* __tstate = wxPyBeginAllowThreads();
3508 result = (long)wxNewId();
3509
3510 wxPyEndAllowThreads(__tstate);
3511 if (PyErr_Occurred()) SWIG_fail;
3512 }
3513 {
3514 resultobj = SWIG_From_long((long)(result));
3515 }
3516 return resultobj;
3517 fail:
3518 return NULL;
3519 }
3520
3521
3522 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3523 PyObject *resultobj;
3524 long arg1 ;
3525 PyObject * obj0 = 0 ;
3526 char *kwnames[] = {
3527 (char *) "id", NULL
3528 };
3529
3530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3531 {
3532 arg1 = (long)(SWIG_As_long(obj0));
3533 if (SWIG_arg_fail(1)) SWIG_fail;
3534 }
3535 {
3536 PyThreadState* __tstate = wxPyBeginAllowThreads();
3537 wxRegisterId(arg1);
3538
3539 wxPyEndAllowThreads(__tstate);
3540 if (PyErr_Occurred()) SWIG_fail;
3541 }
3542 Py_INCREF(Py_None); resultobj = Py_None;
3543 return resultobj;
3544 fail:
3545 return NULL;
3546 }
3547
3548
3549 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3550 PyObject *resultobj;
3551 long result;
3552 char *kwnames[] = {
3553 NULL
3554 };
3555
3556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3557 {
3558 PyThreadState* __tstate = wxPyBeginAllowThreads();
3559 result = (long)wxGetCurrentId();
3560
3561 wxPyEndAllowThreads(__tstate);
3562 if (PyErr_Occurred()) SWIG_fail;
3563 }
3564 {
3565 resultobj = SWIG_From_long((long)(result));
3566 }
3567 return resultobj;
3568 fail:
3569 return NULL;
3570 }
3571
3572
3573 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3574 PyObject *resultobj;
3575 int arg1 ;
3576 bool result;
3577 PyObject * obj0 = 0 ;
3578 char *kwnames[] = {
3579 (char *) "id", NULL
3580 };
3581
3582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3583 {
3584 arg1 = (int)(SWIG_As_int(obj0));
3585 if (SWIG_arg_fail(1)) SWIG_fail;
3586 }
3587 {
3588 PyThreadState* __tstate = wxPyBeginAllowThreads();
3589 result = (bool)wxIsStockID(arg1);
3590
3591 wxPyEndAllowThreads(__tstate);
3592 if (PyErr_Occurred()) SWIG_fail;
3593 }
3594 {
3595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3596 }
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 int arg1 ;
3606 wxString *arg2 = 0 ;
3607 bool result;
3608 bool temp2 = false ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "id",(char *) "label", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3616 {
3617 arg1 = (int)(SWIG_As_int(obj0));
3618 if (SWIG_arg_fail(1)) SWIG_fail;
3619 }
3620 {
3621 arg2 = wxString_in_helper(obj1);
3622 if (arg2 == NULL) SWIG_fail;
3623 temp2 = true;
3624 }
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 {
3633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3634 }
3635 {
3636 if (temp2)
3637 delete arg2;
3638 }
3639 return resultobj;
3640 fail:
3641 {
3642 if (temp2)
3643 delete arg2;
3644 }
3645 return NULL;
3646 }
3647
3648
3649 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3650 PyObject *resultobj;
3651 int arg1 ;
3652 bool arg2 = (bool) true ;
3653 wxString arg3 = (wxString) wxPyEmptyString ;
3654 wxString result;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 PyObject * obj2 = 0 ;
3658 char *kwnames[] = {
3659 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3660 };
3661
3662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3663 {
3664 arg1 = (int)(SWIG_As_int(obj0));
3665 if (SWIG_arg_fail(1)) SWIG_fail;
3666 }
3667 if (obj1) {
3668 {
3669 arg2 = (bool)(SWIG_As_bool(obj1));
3670 if (SWIG_arg_fail(2)) SWIG_fail;
3671 }
3672 }
3673 if (obj2) {
3674 {
3675 wxString* sptr = wxString_in_helper(obj2);
3676 if (sptr == NULL) SWIG_fail;
3677 arg3 = *sptr;
3678 delete sptr;
3679 }
3680 }
3681 {
3682 PyThreadState* __tstate = wxPyBeginAllowThreads();
3683 result = wxGetStockLabel(arg1,arg2,arg3);
3684
3685 wxPyEndAllowThreads(__tstate);
3686 if (PyErr_Occurred()) SWIG_fail;
3687 }
3688 {
3689 #if wxUSE_UNICODE
3690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3691 #else
3692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3693 #endif
3694 }
3695 return resultobj;
3696 fail:
3697 return NULL;
3698 }
3699
3700
3701 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3702 PyObject *resultobj;
3703 char *kwnames[] = {
3704 NULL
3705 };
3706
3707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3708 {
3709 if (!wxPyCheckForApp()) SWIG_fail;
3710 PyThreadState* __tstate = wxPyBeginAllowThreads();
3711 wxBell();
3712
3713 wxPyEndAllowThreads(__tstate);
3714 if (PyErr_Occurred()) SWIG_fail;
3715 }
3716 Py_INCREF(Py_None); resultobj = Py_None;
3717 return resultobj;
3718 fail:
3719 return NULL;
3720 }
3721
3722
3723 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj;
3725 char *kwnames[] = {
3726 NULL
3727 };
3728
3729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3730 {
3731 if (!wxPyCheckForApp()) SWIG_fail;
3732 PyThreadState* __tstate = wxPyBeginAllowThreads();
3733 wxEndBusyCursor();
3734
3735 wxPyEndAllowThreads(__tstate);
3736 if (PyErr_Occurred()) SWIG_fail;
3737 }
3738 Py_INCREF(Py_None); resultobj = Py_None;
3739 return resultobj;
3740 fail:
3741 return NULL;
3742 }
3743
3744
3745 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3746 PyObject *resultobj;
3747 bool arg1 = (bool) true ;
3748 long result;
3749 PyObject * obj0 = 0 ;
3750 char *kwnames[] = {
3751 (char *) "resetTimer", NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3755 if (obj0) {
3756 {
3757 arg1 = (bool)(SWIG_As_bool(obj0));
3758 if (SWIG_arg_fail(1)) SWIG_fail;
3759 }
3760 }
3761 {
3762 PyThreadState* __tstate = wxPyBeginAllowThreads();
3763 result = (long)wxGetElapsedTime(arg1);
3764
3765 wxPyEndAllowThreads(__tstate);
3766 if (PyErr_Occurred()) SWIG_fail;
3767 }
3768 {
3769 resultobj = SWIG_From_long((long)(result));
3770 }
3771 return resultobj;
3772 fail:
3773 return NULL;
3774 }
3775
3776
3777 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3778 PyObject *resultobj;
3779 int *arg1 = (int *) 0 ;
3780 int *arg2 = (int *) 0 ;
3781 int temp1 ;
3782 int res1 = 0 ;
3783 int temp2 ;
3784 int res2 = 0 ;
3785 char *kwnames[] = {
3786 NULL
3787 };
3788
3789 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3790 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3792 {
3793 if (!wxPyCheckForApp()) SWIG_fail;
3794 PyThreadState* __tstate = wxPyBeginAllowThreads();
3795 wxGetMousePosition(arg1,arg2);
3796
3797 wxPyEndAllowThreads(__tstate);
3798 if (PyErr_Occurred()) SWIG_fail;
3799 }
3800 Py_INCREF(Py_None); resultobj = Py_None;
3801 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3802 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3803 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3804 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3805 return resultobj;
3806 fail:
3807 return NULL;
3808 }
3809
3810
3811 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj;
3813 bool result;
3814 char *kwnames[] = {
3815 NULL
3816 };
3817
3818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3819 {
3820 PyThreadState* __tstate = wxPyBeginAllowThreads();
3821 result = (bool)wxIsBusy();
3822
3823 wxPyEndAllowThreads(__tstate);
3824 if (PyErr_Occurred()) SWIG_fail;
3825 }
3826 {
3827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3828 }
3829 return resultobj;
3830 fail:
3831 return NULL;
3832 }
3833
3834
3835 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3836 PyObject *resultobj;
3837 wxString result;
3838 char *kwnames[] = {
3839 NULL
3840 };
3841
3842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = wxNow();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 #if wxUSE_UNICODE
3852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3853 #else
3854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3855 #endif
3856 }
3857 return resultobj;
3858 fail:
3859 return NULL;
3860 }
3861
3862
3863 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3864 PyObject *resultobj;
3865 wxString const &arg1_defvalue = wxPyEmptyString ;
3866 wxString *arg1 = (wxString *) &arg1_defvalue ;
3867 bool result;
3868 bool temp1 = false ;
3869 PyObject * obj0 = 0 ;
3870 char *kwnames[] = {
3871 (char *) "command", NULL
3872 };
3873
3874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3875 if (obj0) {
3876 {
3877 arg1 = wxString_in_helper(obj0);
3878 if (arg1 == NULL) SWIG_fail;
3879 temp1 = true;
3880 }
3881 }
3882 {
3883 PyThreadState* __tstate = wxPyBeginAllowThreads();
3884 result = (bool)wxShell((wxString const &)*arg1);
3885
3886 wxPyEndAllowThreads(__tstate);
3887 if (PyErr_Occurred()) SWIG_fail;
3888 }
3889 {
3890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3891 }
3892 {
3893 if (temp1)
3894 delete arg1;
3895 }
3896 return resultobj;
3897 fail:
3898 {
3899 if (temp1)
3900 delete arg1;
3901 }
3902 return NULL;
3903 }
3904
3905
3906 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3907 PyObject *resultobj;
3908 char *kwnames[] = {
3909 NULL
3910 };
3911
3912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3913 {
3914 PyThreadState* __tstate = wxPyBeginAllowThreads();
3915 wxStartTimer();
3916
3917 wxPyEndAllowThreads(__tstate);
3918 if (PyErr_Occurred()) SWIG_fail;
3919 }
3920 Py_INCREF(Py_None); resultobj = Py_None;
3921 return resultobj;
3922 fail:
3923 return NULL;
3924 }
3925
3926
3927 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3928 PyObject *resultobj;
3929 int *arg1 = (int *) 0 ;
3930 int *arg2 = (int *) 0 ;
3931 int result;
3932 int temp1 ;
3933 int res1 = 0 ;
3934 int temp2 ;
3935 int res2 = 0 ;
3936 char *kwnames[] = {
3937 NULL
3938 };
3939
3940 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3941 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3943 {
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 result = (int)wxGetOsVersion(arg1,arg2);
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 {
3951 resultobj = SWIG_From_int((int)(result));
3952 }
3953 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3954 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3955 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3956 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3957 return resultobj;
3958 fail:
3959 return NULL;
3960 }
3961
3962
3963 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3964 PyObject *resultobj;
3965 wxString result;
3966 char *kwnames[] = {
3967 NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 result = wxGetOsDescription();
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 {
3979 #if wxUSE_UNICODE
3980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3981 #else
3982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3983 #endif
3984 }
3985 return resultobj;
3986 fail:
3987 return NULL;
3988 }
3989
3990
3991 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3992 PyObject *resultobj;
3993 long result;
3994 char *kwnames[] = {
3995 NULL
3996 };
3997
3998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3999 {
4000 PyThreadState* __tstate = wxPyBeginAllowThreads();
4001 result = (long)wxGetFreeMemory();
4002
4003 wxPyEndAllowThreads(__tstate);
4004 if (PyErr_Occurred()) SWIG_fail;
4005 }
4006 {
4007 resultobj = SWIG_From_long((long)(result));
4008 }
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj;
4017 wxShutdownFlags arg1 ;
4018 bool result;
4019 PyObject * obj0 = 0 ;
4020 char *kwnames[] = {
4021 (char *) "wFlags", NULL
4022 };
4023
4024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4025 {
4026 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4027 if (SWIG_arg_fail(1)) SWIG_fail;
4028 }
4029 {
4030 if (!wxPyCheckForApp()) SWIG_fail;
4031 PyThreadState* __tstate = wxPyBeginAllowThreads();
4032 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4033
4034 wxPyEndAllowThreads(__tstate);
4035 if (PyErr_Occurred()) SWIG_fail;
4036 }
4037 {
4038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4039 }
4040 return resultobj;
4041 fail:
4042 return NULL;
4043 }
4044
4045
4046 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4047 PyObject *resultobj;
4048 int arg1 ;
4049 PyObject * obj0 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "secs", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4055 {
4056 arg1 = (int)(SWIG_As_int(obj0));
4057 if (SWIG_arg_fail(1)) SWIG_fail;
4058 }
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 wxSleep(arg1);
4062
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 Py_INCREF(Py_None); resultobj = Py_None;
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4074 PyObject *resultobj;
4075 unsigned long arg1 ;
4076 PyObject * obj0 = 0 ;
4077 char *kwnames[] = {
4078 (char *) "milliseconds", NULL
4079 };
4080
4081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4082 {
4083 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4084 if (SWIG_arg_fail(1)) SWIG_fail;
4085 }
4086 {
4087 PyThreadState* __tstate = wxPyBeginAllowThreads();
4088 wxMilliSleep(arg1);
4089
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 Py_INCREF(Py_None); resultobj = Py_None;
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj;
4102 unsigned long arg1 ;
4103 PyObject * obj0 = 0 ;
4104 char *kwnames[] = {
4105 (char *) "microseconds", NULL
4106 };
4107
4108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4109 {
4110 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4111 if (SWIG_arg_fail(1)) SWIG_fail;
4112 }
4113 {
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 wxMicroSleep(arg1);
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 Py_INCREF(Py_None); resultobj = Py_None;
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj;
4129 bool arg1 ;
4130 PyObject * obj0 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "enable", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4136 {
4137 arg1 = (bool)(SWIG_As_bool(obj0));
4138 if (SWIG_arg_fail(1)) SWIG_fail;
4139 }
4140 {
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 wxEnableTopLevelWindows(arg1);
4143
4144 wxPyEndAllowThreads(__tstate);
4145 if (PyErr_Occurred()) SWIG_fail;
4146 }
4147 Py_INCREF(Py_None); resultobj = Py_None;
4148 return resultobj;
4149 fail:
4150 return NULL;
4151 }
4152
4153
4154 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4155 PyObject *resultobj;
4156 wxString *arg1 = 0 ;
4157 wxString result;
4158 bool temp1 = false ;
4159 PyObject * obj0 = 0 ;
4160 char *kwnames[] = {
4161 (char *) "in", NULL
4162 };
4163
4164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4165 {
4166 arg1 = wxString_in_helper(obj0);
4167 if (arg1 == NULL) SWIG_fail;
4168 temp1 = true;
4169 }
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = wxStripMenuCodes((wxString const &)*arg1);
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 #if wxUSE_UNICODE
4179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4180 #else
4181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4182 #endif
4183 }
4184 {
4185 if (temp1)
4186 delete arg1;
4187 }
4188 return resultobj;
4189 fail:
4190 {
4191 if (temp1)
4192 delete arg1;
4193 }
4194 return NULL;
4195 }
4196
4197
4198 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj;
4200 wxString result;
4201 char *kwnames[] = {
4202 NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4206 {
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = wxGetEmailAddress();
4209
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 #if wxUSE_UNICODE
4215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4216 #else
4217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4218 #endif
4219 }
4220 return resultobj;
4221 fail:
4222 return NULL;
4223 }
4224
4225
4226 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4227 PyObject *resultobj;
4228 wxString result;
4229 char *kwnames[] = {
4230 NULL
4231 };
4232
4233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4234 {
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = wxGetHostName();
4237
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 {
4242 #if wxUSE_UNICODE
4243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4244 #else
4245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4246 #endif
4247 }
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4255 PyObject *resultobj;
4256 wxString result;
4257 char *kwnames[] = {
4258 NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4262 {
4263 PyThreadState* __tstate = wxPyBeginAllowThreads();
4264 result = wxGetFullHostName();
4265
4266 wxPyEndAllowThreads(__tstate);
4267 if (PyErr_Occurred()) SWIG_fail;
4268 }
4269 {
4270 #if wxUSE_UNICODE
4271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4272 #else
4273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4274 #endif
4275 }
4276 return resultobj;
4277 fail:
4278 return NULL;
4279 }
4280
4281
4282 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj;
4284 wxString result;
4285 char *kwnames[] = {
4286 NULL
4287 };
4288
4289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 result = wxGetUserId();
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 {
4298 #if wxUSE_UNICODE
4299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4300 #else
4301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4302 #endif
4303 }
4304 return resultobj;
4305 fail:
4306 return NULL;
4307 }
4308
4309
4310 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4311 PyObject *resultobj;
4312 wxString result;
4313 char *kwnames[] = {
4314 NULL
4315 };
4316
4317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = wxGetUserName();
4321
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 {
4326 #if wxUSE_UNICODE
4327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4328 #else
4329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4330 #endif
4331 }
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj;
4340 wxString result;
4341 char *kwnames[] = {
4342 NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4346 {
4347 PyThreadState* __tstate = wxPyBeginAllowThreads();
4348 result = wxGetHomeDir();
4349
4350 wxPyEndAllowThreads(__tstate);
4351 if (PyErr_Occurred()) SWIG_fail;
4352 }
4353 {
4354 #if wxUSE_UNICODE
4355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4356 #else
4357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4358 #endif
4359 }
4360 return resultobj;
4361 fail:
4362 return NULL;
4363 }
4364
4365
4366 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4367 PyObject *resultobj;
4368 wxString const &arg1_defvalue = wxPyEmptyString ;
4369 wxString *arg1 = (wxString *) &arg1_defvalue ;
4370 wxString result;
4371 bool temp1 = false ;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "user", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4378 if (obj0) {
4379 {
4380 arg1 = wxString_in_helper(obj0);
4381 if (arg1 == NULL) SWIG_fail;
4382 temp1 = true;
4383 }
4384 }
4385 {
4386 PyThreadState* __tstate = wxPyBeginAllowThreads();
4387 result = wxGetUserHome((wxString const &)*arg1);
4388
4389 wxPyEndAllowThreads(__tstate);
4390 if (PyErr_Occurred()) SWIG_fail;
4391 }
4392 {
4393 #if wxUSE_UNICODE
4394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4395 #else
4396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4397 #endif
4398 }
4399 {
4400 if (temp1)
4401 delete arg1;
4402 }
4403 return resultobj;
4404 fail:
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return NULL;
4410 }
4411
4412
4413 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj;
4415 unsigned long result;
4416 char *kwnames[] = {
4417 NULL
4418 };
4419
4420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 result = (unsigned long)wxGetProcessId();
4424
4425 wxPyEndAllowThreads(__tstate);
4426 if (PyErr_Occurred()) SWIG_fail;
4427 }
4428 {
4429 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4430 }
4431 return resultobj;
4432 fail:
4433 return NULL;
4434 }
4435
4436
4437 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4438 PyObject *resultobj;
4439 char *kwnames[] = {
4440 NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 wxTrap();
4447
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 Py_INCREF(Py_None); resultobj = Py_None;
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4459 PyObject *resultobj;
4460 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4461 wxString *arg1 = (wxString *) &arg1_defvalue ;
4462 wxString const &arg2_defvalue = wxPyEmptyString ;
4463 wxString *arg2 = (wxString *) &arg2_defvalue ;
4464 wxString const &arg3_defvalue = wxPyEmptyString ;
4465 wxString *arg3 = (wxString *) &arg3_defvalue ;
4466 wxString const &arg4_defvalue = wxPyEmptyString ;
4467 wxString *arg4 = (wxString *) &arg4_defvalue ;
4468 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4469 wxString *arg5 = (wxString *) &arg5_defvalue ;
4470 int arg6 = (int) 0 ;
4471 wxWindow *arg7 = (wxWindow *) NULL ;
4472 int arg8 = (int) -1 ;
4473 int arg9 = (int) -1 ;
4474 wxString result;
4475 bool temp1 = false ;
4476 bool temp2 = false ;
4477 bool temp3 = false ;
4478 bool temp4 = false ;
4479 bool temp5 = false ;
4480 PyObject * obj0 = 0 ;
4481 PyObject * obj1 = 0 ;
4482 PyObject * obj2 = 0 ;
4483 PyObject * obj3 = 0 ;
4484 PyObject * obj4 = 0 ;
4485 PyObject * obj5 = 0 ;
4486 PyObject * obj6 = 0 ;
4487 PyObject * obj7 = 0 ;
4488 PyObject * obj8 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4494 if (obj0) {
4495 {
4496 arg1 = wxString_in_helper(obj0);
4497 if (arg1 == NULL) SWIG_fail;
4498 temp1 = true;
4499 }
4500 }
4501 if (obj1) {
4502 {
4503 arg2 = wxString_in_helper(obj1);
4504 if (arg2 == NULL) SWIG_fail;
4505 temp2 = true;
4506 }
4507 }
4508 if (obj2) {
4509 {
4510 arg3 = wxString_in_helper(obj2);
4511 if (arg3 == NULL) SWIG_fail;
4512 temp3 = true;
4513 }
4514 }
4515 if (obj3) {
4516 {
4517 arg4 = wxString_in_helper(obj3);
4518 if (arg4 == NULL) SWIG_fail;
4519 temp4 = true;
4520 }
4521 }
4522 if (obj4) {
4523 {
4524 arg5 = wxString_in_helper(obj4);
4525 if (arg5 == NULL) SWIG_fail;
4526 temp5 = true;
4527 }
4528 }
4529 if (obj5) {
4530 {
4531 arg6 = (int)(SWIG_As_int(obj5));
4532 if (SWIG_arg_fail(6)) SWIG_fail;
4533 }
4534 }
4535 if (obj6) {
4536 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(7)) SWIG_fail;
4538 }
4539 if (obj7) {
4540 {
4541 arg8 = (int)(SWIG_As_int(obj7));
4542 if (SWIG_arg_fail(8)) SWIG_fail;
4543 }
4544 }
4545 if (obj8) {
4546 {
4547 arg9 = (int)(SWIG_As_int(obj8));
4548 if (SWIG_arg_fail(9)) SWIG_fail;
4549 }
4550 }
4551 {
4552 if (!wxPyCheckForApp()) SWIG_fail;
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4555
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 #if wxUSE_UNICODE
4561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4562 #else
4563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4564 #endif
4565 }
4566 {
4567 if (temp1)
4568 delete arg1;
4569 }
4570 {
4571 if (temp2)
4572 delete arg2;
4573 }
4574 {
4575 if (temp3)
4576 delete arg3;
4577 }
4578 {
4579 if (temp4)
4580 delete arg4;
4581 }
4582 {
4583 if (temp5)
4584 delete arg5;
4585 }
4586 return resultobj;
4587 fail:
4588 {
4589 if (temp1)
4590 delete arg1;
4591 }
4592 {
4593 if (temp2)
4594 delete arg2;
4595 }
4596 {
4597 if (temp3)
4598 delete arg3;
4599 }
4600 {
4601 if (temp4)
4602 delete arg4;
4603 }
4604 {
4605 if (temp5)
4606 delete arg5;
4607 }
4608 return NULL;
4609 }
4610
4611
4612 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4613 PyObject *resultobj;
4614 wxString *arg1 = 0 ;
4615 wxString *arg2 = 0 ;
4616 wxString const &arg3_defvalue = wxPyEmptyString ;
4617 wxString *arg3 = (wxString *) &arg3_defvalue ;
4618 wxWindow *arg4 = (wxWindow *) NULL ;
4619 wxString result;
4620 bool temp1 = false ;
4621 bool temp2 = false ;
4622 bool temp3 = false ;
4623 PyObject * obj0 = 0 ;
4624 PyObject * obj1 = 0 ;
4625 PyObject * obj2 = 0 ;
4626 PyObject * obj3 = 0 ;
4627 char *kwnames[] = {
4628 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4629 };
4630
4631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4632 {
4633 arg1 = wxString_in_helper(obj0);
4634 if (arg1 == NULL) SWIG_fail;
4635 temp1 = true;
4636 }
4637 {
4638 arg2 = wxString_in_helper(obj1);
4639 if (arg2 == NULL) SWIG_fail;
4640 temp2 = true;
4641 }
4642 if (obj2) {
4643 {
4644 arg3 = wxString_in_helper(obj2);
4645 if (arg3 == NULL) SWIG_fail;
4646 temp3 = true;
4647 }
4648 }
4649 if (obj3) {
4650 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4651 if (SWIG_arg_fail(4)) SWIG_fail;
4652 }
4653 {
4654 if (!wxPyCheckForApp()) SWIG_fail;
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 #if wxUSE_UNICODE
4663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4664 #else
4665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4666 #endif
4667 }
4668 {
4669 if (temp1)
4670 delete arg1;
4671 }
4672 {
4673 if (temp2)
4674 delete arg2;
4675 }
4676 {
4677 if (temp3)
4678 delete arg3;
4679 }
4680 return resultobj;
4681 fail:
4682 {
4683 if (temp1)
4684 delete arg1;
4685 }
4686 {
4687 if (temp2)
4688 delete arg2;
4689 }
4690 {
4691 if (temp3)
4692 delete arg3;
4693 }
4694 return NULL;
4695 }
4696
4697
4698 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4699 PyObject *resultobj;
4700 wxString *arg1 = 0 ;
4701 wxString *arg2 = 0 ;
4702 wxString const &arg3_defvalue = wxPyEmptyString ;
4703 wxString *arg3 = (wxString *) &arg3_defvalue ;
4704 wxWindow *arg4 = (wxWindow *) NULL ;
4705 wxString result;
4706 bool temp1 = false ;
4707 bool temp2 = false ;
4708 bool temp3 = false ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 PyObject * obj3 = 0 ;
4713 char *kwnames[] = {
4714 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4715 };
4716
4717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4718 {
4719 arg1 = wxString_in_helper(obj0);
4720 if (arg1 == NULL) SWIG_fail;
4721 temp1 = true;
4722 }
4723 {
4724 arg2 = wxString_in_helper(obj1);
4725 if (arg2 == NULL) SWIG_fail;
4726 temp2 = true;
4727 }
4728 if (obj2) {
4729 {
4730 arg3 = wxString_in_helper(obj2);
4731 if (arg3 == NULL) SWIG_fail;
4732 temp3 = true;
4733 }
4734 }
4735 if (obj3) {
4736 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4737 if (SWIG_arg_fail(4)) SWIG_fail;
4738 }
4739 {
4740 if (!wxPyCheckForApp()) SWIG_fail;
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4743
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 {
4748 #if wxUSE_UNICODE
4749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4750 #else
4751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4752 #endif
4753 }
4754 {
4755 if (temp1)
4756 delete arg1;
4757 }
4758 {
4759 if (temp2)
4760 delete arg2;
4761 }
4762 {
4763 if (temp3)
4764 delete arg3;
4765 }
4766 return resultobj;
4767 fail:
4768 {
4769 if (temp1)
4770 delete arg1;
4771 }
4772 {
4773 if (temp2)
4774 delete arg2;
4775 }
4776 {
4777 if (temp3)
4778 delete arg3;
4779 }
4780 return NULL;
4781 }
4782
4783
4784 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4787 wxString *arg1 = (wxString *) &arg1_defvalue ;
4788 wxString const &arg2_defvalue = wxPyEmptyString ;
4789 wxString *arg2 = (wxString *) &arg2_defvalue ;
4790 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4791 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4792 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4793 wxWindow *arg5 = (wxWindow *) NULL ;
4794 wxString result;
4795 bool temp1 = false ;
4796 bool temp2 = false ;
4797 wxPoint temp4 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 PyObject * obj2 = 0 ;
4801 PyObject * obj3 = 0 ;
4802 PyObject * obj4 = 0 ;
4803 char *kwnames[] = {
4804 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4805 };
4806
4807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4808 if (obj0) {
4809 {
4810 arg1 = wxString_in_helper(obj0);
4811 if (arg1 == NULL) SWIG_fail;
4812 temp1 = true;
4813 }
4814 }
4815 if (obj1) {
4816 {
4817 arg2 = wxString_in_helper(obj1);
4818 if (arg2 == NULL) SWIG_fail;
4819 temp2 = true;
4820 }
4821 }
4822 if (obj2) {
4823 {
4824 arg3 = (long)(SWIG_As_long(obj2));
4825 if (SWIG_arg_fail(3)) SWIG_fail;
4826 }
4827 }
4828 if (obj3) {
4829 {
4830 arg4 = &temp4;
4831 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4832 }
4833 }
4834 if (obj4) {
4835 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4836 if (SWIG_arg_fail(5)) SWIG_fail;
4837 }
4838 {
4839 if (!wxPyCheckForApp()) SWIG_fail;
4840 PyThreadState* __tstate = wxPyBeginAllowThreads();
4841 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4842
4843 wxPyEndAllowThreads(__tstate);
4844 if (PyErr_Occurred()) SWIG_fail;
4845 }
4846 {
4847 #if wxUSE_UNICODE
4848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4849 #else
4850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4851 #endif
4852 }
4853 {
4854 if (temp1)
4855 delete arg1;
4856 }
4857 {
4858 if (temp2)
4859 delete arg2;
4860 }
4861 return resultobj;
4862 fail:
4863 {
4864 if (temp1)
4865 delete arg1;
4866 }
4867 {
4868 if (temp2)
4869 delete arg2;
4870 }
4871 return NULL;
4872 }
4873
4874
4875 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4876 PyObject *resultobj;
4877 wxString *arg1 = 0 ;
4878 wxString const &arg2_defvalue = wxPyEmptyString ;
4879 wxString *arg2 = (wxString *) &arg2_defvalue ;
4880 wxString const &arg3_defvalue = wxPyEmptyString ;
4881 wxString *arg3 = (wxString *) &arg3_defvalue ;
4882 wxWindow *arg4 = (wxWindow *) NULL ;
4883 int arg5 = (int) -1 ;
4884 int arg6 = (int) -1 ;
4885 bool arg7 = (bool) true ;
4886 wxString result;
4887 bool temp1 = false ;
4888 bool temp2 = false ;
4889 bool temp3 = false ;
4890 PyObject * obj0 = 0 ;
4891 PyObject * obj1 = 0 ;
4892 PyObject * obj2 = 0 ;
4893 PyObject * obj3 = 0 ;
4894 PyObject * obj4 = 0 ;
4895 PyObject * obj5 = 0 ;
4896 PyObject * obj6 = 0 ;
4897 char *kwnames[] = {
4898 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4899 };
4900
4901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4902 {
4903 arg1 = wxString_in_helper(obj0);
4904 if (arg1 == NULL) SWIG_fail;
4905 temp1 = true;
4906 }
4907 if (obj1) {
4908 {
4909 arg2 = wxString_in_helper(obj1);
4910 if (arg2 == NULL) SWIG_fail;
4911 temp2 = true;
4912 }
4913 }
4914 if (obj2) {
4915 {
4916 arg3 = wxString_in_helper(obj2);
4917 if (arg3 == NULL) SWIG_fail;
4918 temp3 = true;
4919 }
4920 }
4921 if (obj3) {
4922 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(4)) SWIG_fail;
4924 }
4925 if (obj4) {
4926 {
4927 arg5 = (int)(SWIG_As_int(obj4));
4928 if (SWIG_arg_fail(5)) SWIG_fail;
4929 }
4930 }
4931 if (obj5) {
4932 {
4933 arg6 = (int)(SWIG_As_int(obj5));
4934 if (SWIG_arg_fail(6)) SWIG_fail;
4935 }
4936 }
4937 if (obj6) {
4938 {
4939 arg7 = (bool)(SWIG_As_bool(obj6));
4940 if (SWIG_arg_fail(7)) SWIG_fail;
4941 }
4942 }
4943 {
4944 if (!wxPyCheckForApp()) SWIG_fail;
4945 PyThreadState* __tstate = wxPyBeginAllowThreads();
4946 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4947
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 {
4952 #if wxUSE_UNICODE
4953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4954 #else
4955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4956 #endif
4957 }
4958 {
4959 if (temp1)
4960 delete arg1;
4961 }
4962 {
4963 if (temp2)
4964 delete arg2;
4965 }
4966 {
4967 if (temp3)
4968 delete arg3;
4969 }
4970 return resultobj;
4971 fail:
4972 {
4973 if (temp1)
4974 delete arg1;
4975 }
4976 {
4977 if (temp2)
4978 delete arg2;
4979 }
4980 {
4981 if (temp3)
4982 delete arg3;
4983 }
4984 return NULL;
4985 }
4986
4987
4988 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4989 PyObject *resultobj;
4990 wxString *arg1 = 0 ;
4991 wxString const &arg2_defvalue = wxPyEmptyString ;
4992 wxString *arg2 = (wxString *) &arg2_defvalue ;
4993 wxString const &arg3_defvalue = wxPyEmptyString ;
4994 wxString *arg3 = (wxString *) &arg3_defvalue ;
4995 wxWindow *arg4 = (wxWindow *) NULL ;
4996 wxString result;
4997 bool temp1 = false ;
4998 bool temp2 = false ;
4999 bool temp3 = false ;
5000 PyObject * obj0 = 0 ;
5001 PyObject * obj1 = 0 ;
5002 PyObject * obj2 = 0 ;
5003 PyObject * obj3 = 0 ;
5004 char *kwnames[] = {
5005 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5006 };
5007
5008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5009 {
5010 arg1 = wxString_in_helper(obj0);
5011 if (arg1 == NULL) SWIG_fail;
5012 temp1 = true;
5013 }
5014 if (obj1) {
5015 {
5016 arg2 = wxString_in_helper(obj1);
5017 if (arg2 == NULL) SWIG_fail;
5018 temp2 = true;
5019 }
5020 }
5021 if (obj2) {
5022 {
5023 arg3 = wxString_in_helper(obj2);
5024 if (arg3 == NULL) SWIG_fail;
5025 temp3 = true;
5026 }
5027 }
5028 if (obj3) {
5029 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5030 if (SWIG_arg_fail(4)) SWIG_fail;
5031 }
5032 {
5033 if (!wxPyCheckForApp()) SWIG_fail;
5034 PyThreadState* __tstate = wxPyBeginAllowThreads();
5035 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5036
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 #if wxUSE_UNICODE
5042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5043 #else
5044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5045 #endif
5046 }
5047 {
5048 if (temp1)
5049 delete arg1;
5050 }
5051 {
5052 if (temp2)
5053 delete arg2;
5054 }
5055 {
5056 if (temp3)
5057 delete arg3;
5058 }
5059 return resultobj;
5060 fail:
5061 {
5062 if (temp1)
5063 delete arg1;
5064 }
5065 {
5066 if (temp2)
5067 delete arg2;
5068 }
5069 {
5070 if (temp3)
5071 delete arg3;
5072 }
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj;
5079 wxString *arg1 = 0 ;
5080 wxString *arg2 = 0 ;
5081 int arg3 ;
5082 wxString *arg4 = (wxString *) 0 ;
5083 wxWindow *arg5 = (wxWindow *) NULL ;
5084 int arg6 = (int) -1 ;
5085 int arg7 = (int) -1 ;
5086 bool arg8 = (bool) true ;
5087 int arg9 = (int) 150 ;
5088 int arg10 = (int) 200 ;
5089 wxString result;
5090 bool temp1 = false ;
5091 bool temp2 = false ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 PyObject * obj3 = 0 ;
5096 PyObject * obj4 = 0 ;
5097 PyObject * obj5 = 0 ;
5098 PyObject * obj6 = 0 ;
5099 PyObject * obj7 = 0 ;
5100 PyObject * obj8 = 0 ;
5101 char *kwnames[] = {
5102 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5103 };
5104
5105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5106 {
5107 arg1 = wxString_in_helper(obj0);
5108 if (arg1 == NULL) SWIG_fail;
5109 temp1 = true;
5110 }
5111 {
5112 arg2 = wxString_in_helper(obj1);
5113 if (arg2 == NULL) SWIG_fail;
5114 temp2 = true;
5115 }
5116 {
5117 arg3 = PyList_Size(obj2);
5118 arg4 = wxString_LIST_helper(obj2);
5119 if (arg4 == NULL) SWIG_fail;
5120 }
5121 if (obj3) {
5122 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5123 if (SWIG_arg_fail(5)) SWIG_fail;
5124 }
5125 if (obj4) {
5126 {
5127 arg6 = (int)(SWIG_As_int(obj4));
5128 if (SWIG_arg_fail(6)) SWIG_fail;
5129 }
5130 }
5131 if (obj5) {
5132 {
5133 arg7 = (int)(SWIG_As_int(obj5));
5134 if (SWIG_arg_fail(7)) SWIG_fail;
5135 }
5136 }
5137 if (obj6) {
5138 {
5139 arg8 = (bool)(SWIG_As_bool(obj6));
5140 if (SWIG_arg_fail(8)) SWIG_fail;
5141 }
5142 }
5143 if (obj7) {
5144 {
5145 arg9 = (int)(SWIG_As_int(obj7));
5146 if (SWIG_arg_fail(9)) SWIG_fail;
5147 }
5148 }
5149 if (obj8) {
5150 {
5151 arg10 = (int)(SWIG_As_int(obj8));
5152 if (SWIG_arg_fail(10)) SWIG_fail;
5153 }
5154 }
5155 {
5156 if (!wxPyCheckForApp()) SWIG_fail;
5157 PyThreadState* __tstate = wxPyBeginAllowThreads();
5158 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5159
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 {
5164 #if wxUSE_UNICODE
5165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5166 #else
5167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5168 #endif
5169 }
5170 {
5171 if (temp1)
5172 delete arg1;
5173 }
5174 {
5175 if (temp2)
5176 delete arg2;
5177 }
5178 {
5179 if (arg4) delete [] arg4;
5180 }
5181 return resultobj;
5182 fail:
5183 {
5184 if (temp1)
5185 delete arg1;
5186 }
5187 {
5188 if (temp2)
5189 delete arg2;
5190 }
5191 {
5192 if (arg4) delete [] arg4;
5193 }
5194 return NULL;
5195 }
5196
5197
5198 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5199 PyObject *resultobj;
5200 wxString *arg1 = 0 ;
5201 wxString *arg2 = 0 ;
5202 int arg3 ;
5203 wxString *arg4 = (wxString *) 0 ;
5204 wxWindow *arg5 = (wxWindow *) NULL ;
5205 int arg6 = (int) -1 ;
5206 int arg7 = (int) -1 ;
5207 bool arg8 = (bool) true ;
5208 int arg9 = (int) 150 ;
5209 int arg10 = (int) 200 ;
5210 int result;
5211 bool temp1 = false ;
5212 bool temp2 = false ;
5213 PyObject * obj0 = 0 ;
5214 PyObject * obj1 = 0 ;
5215 PyObject * obj2 = 0 ;
5216 PyObject * obj3 = 0 ;
5217 PyObject * obj4 = 0 ;
5218 PyObject * obj5 = 0 ;
5219 PyObject * obj6 = 0 ;
5220 PyObject * obj7 = 0 ;
5221 PyObject * obj8 = 0 ;
5222 char *kwnames[] = {
5223 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5224 };
5225
5226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5227 {
5228 arg1 = wxString_in_helper(obj0);
5229 if (arg1 == NULL) SWIG_fail;
5230 temp1 = true;
5231 }
5232 {
5233 arg2 = wxString_in_helper(obj1);
5234 if (arg2 == NULL) SWIG_fail;
5235 temp2 = true;
5236 }
5237 {
5238 arg3 = PyList_Size(obj2);
5239 arg4 = wxString_LIST_helper(obj2);
5240 if (arg4 == NULL) SWIG_fail;
5241 }
5242 if (obj3) {
5243 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5244 if (SWIG_arg_fail(5)) SWIG_fail;
5245 }
5246 if (obj4) {
5247 {
5248 arg6 = (int)(SWIG_As_int(obj4));
5249 if (SWIG_arg_fail(6)) SWIG_fail;
5250 }
5251 }
5252 if (obj5) {
5253 {
5254 arg7 = (int)(SWIG_As_int(obj5));
5255 if (SWIG_arg_fail(7)) SWIG_fail;
5256 }
5257 }
5258 if (obj6) {
5259 {
5260 arg8 = (bool)(SWIG_As_bool(obj6));
5261 if (SWIG_arg_fail(8)) SWIG_fail;
5262 }
5263 }
5264 if (obj7) {
5265 {
5266 arg9 = (int)(SWIG_As_int(obj7));
5267 if (SWIG_arg_fail(9)) SWIG_fail;
5268 }
5269 }
5270 if (obj8) {
5271 {
5272 arg10 = (int)(SWIG_As_int(obj8));
5273 if (SWIG_arg_fail(10)) SWIG_fail;
5274 }
5275 }
5276 {
5277 if (!wxPyCheckForApp()) SWIG_fail;
5278 PyThreadState* __tstate = wxPyBeginAllowThreads();
5279 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5280
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 {
5285 resultobj = SWIG_From_int((int)(result));
5286 }
5287 {
5288 if (temp1)
5289 delete arg1;
5290 }
5291 {
5292 if (temp2)
5293 delete arg2;
5294 }
5295 {
5296 if (arg4) delete [] arg4;
5297 }
5298 return resultobj;
5299 fail:
5300 {
5301 if (temp1)
5302 delete arg1;
5303 }
5304 {
5305 if (temp2)
5306 delete arg2;
5307 }
5308 {
5309 if (arg4) delete [] arg4;
5310 }
5311 return NULL;
5312 }
5313
5314
5315 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj;
5317 wxString *arg1 = 0 ;
5318 wxString const &arg2_defvalue = wxPyEmptyString ;
5319 wxString *arg2 = (wxString *) &arg2_defvalue ;
5320 int arg3 = (int) wxOK|wxCENTRE ;
5321 wxWindow *arg4 = (wxWindow *) NULL ;
5322 int arg5 = (int) -1 ;
5323 int arg6 = (int) -1 ;
5324 int result;
5325 bool temp1 = false ;
5326 bool temp2 = false ;
5327 PyObject * obj0 = 0 ;
5328 PyObject * obj1 = 0 ;
5329 PyObject * obj2 = 0 ;
5330 PyObject * obj3 = 0 ;
5331 PyObject * obj4 = 0 ;
5332 PyObject * obj5 = 0 ;
5333 char *kwnames[] = {
5334 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5335 };
5336
5337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5338 {
5339 arg1 = wxString_in_helper(obj0);
5340 if (arg1 == NULL) SWIG_fail;
5341 temp1 = true;
5342 }
5343 if (obj1) {
5344 {
5345 arg2 = wxString_in_helper(obj1);
5346 if (arg2 == NULL) SWIG_fail;
5347 temp2 = true;
5348 }
5349 }
5350 if (obj2) {
5351 {
5352 arg3 = (int)(SWIG_As_int(obj2));
5353 if (SWIG_arg_fail(3)) SWIG_fail;
5354 }
5355 }
5356 if (obj3) {
5357 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5358 if (SWIG_arg_fail(4)) SWIG_fail;
5359 }
5360 if (obj4) {
5361 {
5362 arg5 = (int)(SWIG_As_int(obj4));
5363 if (SWIG_arg_fail(5)) SWIG_fail;
5364 }
5365 }
5366 if (obj5) {
5367 {
5368 arg6 = (int)(SWIG_As_int(obj5));
5369 if (SWIG_arg_fail(6)) SWIG_fail;
5370 }
5371 }
5372 {
5373 if (!wxPyCheckForApp()) SWIG_fail;
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5376
5377 wxPyEndAllowThreads(__tstate);
5378 if (PyErr_Occurred()) SWIG_fail;
5379 }
5380 {
5381 resultobj = SWIG_From_int((int)(result));
5382 }
5383 {
5384 if (temp1)
5385 delete arg1;
5386 }
5387 {
5388 if (temp2)
5389 delete arg2;
5390 }
5391 return resultobj;
5392 fail:
5393 {
5394 if (temp1)
5395 delete arg1;
5396 }
5397 {
5398 if (temp2)
5399 delete arg2;
5400 }
5401 return NULL;
5402 }
5403
5404
5405 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5406 PyObject *resultobj;
5407 wxString *arg1 = 0 ;
5408 wxString *arg2 = 0 ;
5409 wxString *arg3 = 0 ;
5410 long arg4 ;
5411 long arg5 = (long) 0 ;
5412 long arg6 = (long) 100 ;
5413 wxWindow *arg7 = (wxWindow *) NULL ;
5414 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5415 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5416 long result;
5417 bool temp1 = false ;
5418 bool temp2 = false ;
5419 bool temp3 = false ;
5420 wxPoint temp8 ;
5421 PyObject * obj0 = 0 ;
5422 PyObject * obj1 = 0 ;
5423 PyObject * obj2 = 0 ;
5424 PyObject * obj3 = 0 ;
5425 PyObject * obj4 = 0 ;
5426 PyObject * obj5 = 0 ;
5427 PyObject * obj6 = 0 ;
5428 PyObject * obj7 = 0 ;
5429 char *kwnames[] = {
5430 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5431 };
5432
5433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5434 {
5435 arg1 = wxString_in_helper(obj0);
5436 if (arg1 == NULL) SWIG_fail;
5437 temp1 = true;
5438 }
5439 {
5440 arg2 = wxString_in_helper(obj1);
5441 if (arg2 == NULL) SWIG_fail;
5442 temp2 = true;
5443 }
5444 {
5445 arg3 = wxString_in_helper(obj2);
5446 if (arg3 == NULL) SWIG_fail;
5447 temp3 = true;
5448 }
5449 {
5450 arg4 = (long)(SWIG_As_long(obj3));
5451 if (SWIG_arg_fail(4)) SWIG_fail;
5452 }
5453 if (obj4) {
5454 {
5455 arg5 = (long)(SWIG_As_long(obj4));
5456 if (SWIG_arg_fail(5)) SWIG_fail;
5457 }
5458 }
5459 if (obj5) {
5460 {
5461 arg6 = (long)(SWIG_As_long(obj5));
5462 if (SWIG_arg_fail(6)) SWIG_fail;
5463 }
5464 }
5465 if (obj6) {
5466 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5467 if (SWIG_arg_fail(7)) SWIG_fail;
5468 }
5469 if (obj7) {
5470 {
5471 arg8 = &temp8;
5472 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5473 }
5474 }
5475 {
5476 if (!wxPyCheckForApp()) SWIG_fail;
5477 PyThreadState* __tstate = wxPyBeginAllowThreads();
5478 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5479
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 resultobj = SWIG_From_long((long)(result));
5485 }
5486 {
5487 if (temp1)
5488 delete arg1;
5489 }
5490 {
5491 if (temp2)
5492 delete arg2;
5493 }
5494 {
5495 if (temp3)
5496 delete arg3;
5497 }
5498 return resultobj;
5499 fail:
5500 {
5501 if (temp1)
5502 delete arg1;
5503 }
5504 {
5505 if (temp2)
5506 delete arg2;
5507 }
5508 {
5509 if (temp3)
5510 delete arg3;
5511 }
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 bool result;
5519 char *kwnames[] = {
5520 NULL
5521 };
5522
5523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5524 {
5525 if (!wxPyCheckForApp()) SWIG_fail;
5526 PyThreadState* __tstate = wxPyBeginAllowThreads();
5527 result = (bool)wxColourDisplay();
5528
5529 wxPyEndAllowThreads(__tstate);
5530 if (PyErr_Occurred()) SWIG_fail;
5531 }
5532 {
5533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5534 }
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5542 PyObject *resultobj;
5543 int result;
5544 char *kwnames[] = {
5545 NULL
5546 };
5547
5548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5549 {
5550 if (!wxPyCheckForApp()) SWIG_fail;
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 result = (int)wxDisplayDepth();
5553
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 {
5558 resultobj = SWIG_From_int((int)(result));
5559 }
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5567 PyObject *resultobj;
5568 int result;
5569 char *kwnames[] = {
5570 NULL
5571 };
5572
5573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5574 {
5575 if (!wxPyCheckForApp()) SWIG_fail;
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (int)wxGetDisplayDepth();
5578
5579 wxPyEndAllowThreads(__tstate);
5580 if (PyErr_Occurred()) SWIG_fail;
5581 }
5582 {
5583 resultobj = SWIG_From_int((int)(result));
5584 }
5585 return resultobj;
5586 fail:
5587 return NULL;
5588 }
5589
5590
5591 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5592 PyObject *resultobj;
5593 int *arg1 = (int *) 0 ;
5594 int *arg2 = (int *) 0 ;
5595 int temp1 ;
5596 int res1 = 0 ;
5597 int temp2 ;
5598 int res2 = 0 ;
5599 char *kwnames[] = {
5600 NULL
5601 };
5602
5603 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5604 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5606 {
5607 if (!wxPyCheckForApp()) SWIG_fail;
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 wxDisplaySize(arg1,arg2);
5610
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 Py_INCREF(Py_None); resultobj = Py_None;
5615 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5616 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5617 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5618 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5626 PyObject *resultobj;
5627 wxSize result;
5628 char *kwnames[] = {
5629 NULL
5630 };
5631
5632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5633 {
5634 if (!wxPyCheckForApp()) SWIG_fail;
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = wxGetDisplaySize();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 wxSize * resultptr;
5643 resultptr = new wxSize((wxSize &)(result));
5644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5645 }
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj;
5654 int *arg1 = (int *) 0 ;
5655 int *arg2 = (int *) 0 ;
5656 int temp1 ;
5657 int res1 = 0 ;
5658 int temp2 ;
5659 int res2 = 0 ;
5660 char *kwnames[] = {
5661 NULL
5662 };
5663
5664 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5665 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5667 {
5668 if (!wxPyCheckForApp()) SWIG_fail;
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 wxDisplaySizeMM(arg1,arg2);
5671
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 Py_INCREF(Py_None); resultobj = Py_None;
5676 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5677 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5678 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5679 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxSize result;
5689 char *kwnames[] = {
5690 NULL
5691 };
5692
5693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5694 {
5695 if (!wxPyCheckForApp()) SWIG_fail;
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 result = wxGetDisplaySizeMM();
5698
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 {
5703 wxSize * resultptr;
5704 resultptr = new wxSize((wxSize &)(result));
5705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5706 }
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj;
5715 int *arg1 = (int *) 0 ;
5716 int *arg2 = (int *) 0 ;
5717 int *arg3 = (int *) 0 ;
5718 int *arg4 = (int *) 0 ;
5719 int temp1 ;
5720 int res1 = 0 ;
5721 int temp2 ;
5722 int res2 = 0 ;
5723 int temp3 ;
5724 int res3 = 0 ;
5725 int temp4 ;
5726 int res4 = 0 ;
5727 char *kwnames[] = {
5728 NULL
5729 };
5730
5731 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5732 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5733 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5734 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5736 {
5737 if (!wxPyCheckForApp()) SWIG_fail;
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 Py_INCREF(Py_None); resultobj = Py_None;
5745 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5746 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5747 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5748 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5749 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5750 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5751 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5752 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 wxRect result;
5762 char *kwnames[] = {
5763 NULL
5764 };
5765
5766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5767 {
5768 if (!wxPyCheckForApp()) SWIG_fail;
5769 PyThreadState* __tstate = wxPyBeginAllowThreads();
5770 result = wxGetClientDisplayRect();
5771
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 {
5776 wxRect * resultptr;
5777 resultptr = new wxRect((wxRect &)(result));
5778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5779 }
5780 return resultobj;
5781 fail:
5782 return NULL;
5783 }
5784
5785
5786 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5787 PyObject *resultobj;
5788 wxCursor *arg1 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 char *kwnames[] = {
5791 (char *) "cursor", NULL
5792 };
5793
5794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5795 {
5796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5797 if (SWIG_arg_fail(1)) SWIG_fail;
5798 if (arg1 == NULL) {
5799 SWIG_null_ref("wxCursor");
5800 }
5801 if (SWIG_arg_fail(1)) SWIG_fail;
5802 }
5803 {
5804 if (!wxPyCheckForApp()) SWIG_fail;
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 wxSetCursor(*arg1);
5807
5808 wxPyEndAllowThreads(__tstate);
5809 if (PyErr_Occurred()) SWIG_fail;
5810 }
5811 Py_INCREF(Py_None); resultobj = Py_None;
5812 return resultobj;
5813 fail:
5814 return NULL;
5815 }
5816
5817
5818 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj;
5820 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5821 PyObject * obj0 = 0 ;
5822 char *kwnames[] = {
5823 (char *) "cursor", NULL
5824 };
5825
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5827 if (obj0) {
5828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5829 if (SWIG_arg_fail(1)) SWIG_fail;
5830 }
5831 {
5832 if (!wxPyCheckForApp()) SWIG_fail;
5833 PyThreadState* __tstate = wxPyBeginAllowThreads();
5834 wxBeginBusyCursor(arg1);
5835
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 Py_INCREF(Py_None); resultobj = Py_None;
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj;
5848 wxWindow *result;
5849 char *kwnames[] = {
5850 NULL
5851 };
5852
5853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5854 {
5855 if (!wxPyCheckForApp()) SWIG_fail;
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (wxWindow *)wxGetActiveWindow();
5858
5859 wxPyEndAllowThreads(__tstate);
5860 if (PyErr_Occurred()) SWIG_fail;
5861 }
5862 {
5863 resultobj = wxPyMake_wxObject(result, 0);
5864 }
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj;
5873 wxPoint *arg1 = 0 ;
5874 wxWindow *result;
5875 wxPoint temp1 ;
5876 PyObject * obj0 = 0 ;
5877 char *kwnames[] = {
5878 (char *) "pt", NULL
5879 };
5880
5881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5882 {
5883 arg1 = &temp1;
5884 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5885 }
5886 {
5887 if (!wxPyCheckForApp()) SWIG_fail;
5888 PyThreadState* __tstate = wxPyBeginAllowThreads();
5889 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5890
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 {
5895 resultobj = wxPyMake_wxObject(result, 0);
5896 }
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5904 PyObject *resultobj;
5905 wxPoint *arg1 = 0 ;
5906 wxWindow *result;
5907 wxPoint temp1 ;
5908 PyObject * obj0 = 0 ;
5909 char *kwnames[] = {
5910 (char *) "pt", NULL
5911 };
5912
5913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5914 {
5915 arg1 = &temp1;
5916 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5917 }
5918 {
5919 if (!wxPyCheckForApp()) SWIG_fail;
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 resultobj = wxPyMake_wxObject(result, 0);
5928 }
5929 return resultobj;
5930 fail:
5931 return NULL;
5932 }
5933
5934
5935 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj;
5937 wxWindow *arg1 = (wxWindow *) 0 ;
5938 wxWindow *result;
5939 PyObject * obj0 = 0 ;
5940 char *kwnames[] = {
5941 (char *) "win", NULL
5942 };
5943
5944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5946 if (SWIG_arg_fail(1)) SWIG_fail;
5947 {
5948 if (!wxPyCheckForApp()) SWIG_fail;
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 result = (wxWindow *)wxGetTopLevelParent(arg1);
5951
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 {
5956 resultobj = wxPyMake_wxObject(result, 0);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj;
5966 wxKeyCode arg1 ;
5967 bool result;
5968 PyObject * obj0 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "key", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5974 {
5975 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5976 if (SWIG_arg_fail(1)) SWIG_fail;
5977 }
5978 {
5979 if (!wxPyCheckForApp()) SWIG_fail;
5980 PyThreadState* __tstate = wxPyBeginAllowThreads();
5981 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5982
5983 wxPyEndAllowThreads(__tstate);
5984 if (PyErr_Occurred()) SWIG_fail;
5985 }
5986 {
5987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5988 }
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5996 PyObject *resultobj;
5997 char *kwnames[] = {
5998 NULL
5999 };
6000
6001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6002 {
6003 if (!wxPyCheckForApp()) SWIG_fail;
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 wxWakeUpMainThread();
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 Py_INCREF(Py_None); resultobj = Py_None;
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj;
6019 char *kwnames[] = {
6020 NULL
6021 };
6022
6023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6024 {
6025 if (!wxPyCheckForApp()) SWIG_fail;
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 wxMutexGuiEnter();
6028
6029 wxPyEndAllowThreads(__tstate);
6030 if (PyErr_Occurred()) SWIG_fail;
6031 }
6032 Py_INCREF(Py_None); resultobj = Py_None;
6033 return resultobj;
6034 fail:
6035 return NULL;
6036 }
6037
6038
6039 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6040 PyObject *resultobj;
6041 char *kwnames[] = {
6042 NULL
6043 };
6044
6045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6046 {
6047 if (!wxPyCheckForApp()) SWIG_fail;
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 wxMutexGuiLeave();
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 Py_INCREF(Py_None); resultobj = Py_None;
6055 return resultobj;
6056 fail:
6057 return NULL;
6058 }
6059
6060
6061 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6062 PyObject *resultobj;
6063 wxMutexGuiLocker *result;
6064 char *kwnames[] = {
6065 NULL
6066 };
6067
6068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6069 {
6070 if (!wxPyCheckForApp()) SWIG_fail;
6071 PyThreadState* __tstate = wxPyBeginAllowThreads();
6072 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6073
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj;
6086 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6087 PyObject * obj0 = 0 ;
6088 char *kwnames[] = {
6089 (char *) "self", NULL
6090 };
6091
6092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6094 if (SWIG_arg_fail(1)) SWIG_fail;
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 delete arg1;
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 Py_INCREF(Py_None); resultobj = Py_None;
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6110 PyObject *obj;
6111 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6112 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6113 Py_INCREF(obj);
6114 return Py_BuildValue((char *)"");
6115 }
6116 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 bool result;
6119 char *kwnames[] = {
6120 NULL
6121 };
6122
6123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (bool)wxThread_IsMain();
6127
6128 wxPyEndAllowThreads(__tstate);
6129 if (PyErr_Occurred()) SWIG_fail;
6130 }
6131 {
6132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6133 }
6134 return resultobj;
6135 fail:
6136 return NULL;
6137 }
6138
6139
6140 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6141 PyObject *resultobj;
6142 wxString *arg1 = 0 ;
6143 wxToolTip *result;
6144 bool temp1 = false ;
6145 PyObject * obj0 = 0 ;
6146 char *kwnames[] = {
6147 (char *) "tip", NULL
6148 };
6149
6150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6151 {
6152 arg1 = wxString_in_helper(obj0);
6153 if (arg1 == NULL) SWIG_fail;
6154 temp1 = true;
6155 }
6156 {
6157 if (!wxPyCheckForApp()) SWIG_fail;
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6160
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 {
6165 resultobj = wxPyMake_wxObject(result, 1);
6166 }
6167 {
6168 if (temp1)
6169 delete arg1;
6170 }
6171 return resultobj;
6172 fail:
6173 {
6174 if (temp1)
6175 delete arg1;
6176 }
6177 return NULL;
6178 }
6179
6180
6181 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj;
6183 wxToolTip *arg1 = (wxToolTip *) 0 ;
6184 wxString *arg2 = 0 ;
6185 bool temp2 = false ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self",(char *) "tip", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 {
6196 arg2 = wxString_in_helper(obj1);
6197 if (arg2 == NULL) SWIG_fail;
6198 temp2 = true;
6199 }
6200 {
6201 PyThreadState* __tstate = wxPyBeginAllowThreads();
6202 (arg1)->SetTip((wxString const &)*arg2);
6203
6204 wxPyEndAllowThreads(__tstate);
6205 if (PyErr_Occurred()) SWIG_fail;
6206 }
6207 Py_INCREF(Py_None); resultobj = Py_None;
6208 {
6209 if (temp2)
6210 delete arg2;
6211 }
6212 return resultobj;
6213 fail:
6214 {
6215 if (temp2)
6216 delete arg2;
6217 }
6218 return NULL;
6219 }
6220
6221
6222 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj;
6224 wxToolTip *arg1 = (wxToolTip *) 0 ;
6225 wxString result;
6226 PyObject * obj0 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "self", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6233 if (SWIG_arg_fail(1)) SWIG_fail;
6234 {
6235 PyThreadState* __tstate = wxPyBeginAllowThreads();
6236 result = (arg1)->GetTip();
6237
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 {
6242 #if wxUSE_UNICODE
6243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6244 #else
6245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6246 #endif
6247 }
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6255 PyObject *resultobj;
6256 wxToolTip *arg1 = (wxToolTip *) 0 ;
6257 wxWindow *result;
6258 PyObject * obj0 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 result = (wxWindow *)(arg1)->GetWindow();
6269
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 {
6274 resultobj = wxPyMake_wxObject(result, 0);
6275 }
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj;
6284 bool arg1 ;
6285 PyObject * obj0 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "flag", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6291 {
6292 arg1 = (bool)(SWIG_As_bool(obj0));
6293 if (SWIG_arg_fail(1)) SWIG_fail;
6294 }
6295 {
6296 PyThreadState* __tstate = wxPyBeginAllowThreads();
6297 wxToolTip::Enable(arg1);
6298
6299 wxPyEndAllowThreads(__tstate);
6300 if (PyErr_Occurred()) SWIG_fail;
6301 }
6302 Py_INCREF(Py_None); resultobj = Py_None;
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 long arg1 ;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "milliseconds", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6318 {
6319 arg1 = (long)(SWIG_As_long(obj0));
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 }
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 wxToolTip::SetDelay(arg1);
6325
6326 wxPyEndAllowThreads(__tstate);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 Py_INCREF(Py_None); resultobj = Py_None;
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6337 PyObject *obj;
6338 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6339 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6340 Py_INCREF(obj);
6341 return Py_BuildValue((char *)"");
6342 }
6343 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj;
6345 wxWindow *arg1 = (wxWindow *) 0 ;
6346 wxSize *arg2 = 0 ;
6347 wxCaret *result;
6348 wxSize temp2 ;
6349 PyObject * obj0 = 0 ;
6350 PyObject * obj1 = 0 ;
6351 char *kwnames[] = {
6352 (char *) "window",(char *) "size", NULL
6353 };
6354
6355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6357 if (SWIG_arg_fail(1)) SWIG_fail;
6358 {
6359 arg2 = &temp2;
6360 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6361 }
6362 {
6363 if (!wxPyCheckForApp()) SWIG_fail;
6364 PyThreadState* __tstate = wxPyBeginAllowThreads();
6365 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6366
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj;
6379 wxCaret *arg1 = (wxCaret *) 0 ;
6380 PyObject * obj0 = 0 ;
6381 char *kwnames[] = {
6382 (char *) "self", NULL
6383 };
6384
6385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6387 if (SWIG_arg_fail(1)) SWIG_fail;
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 wxCaret_Destroy(arg1);
6391
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 Py_INCREF(Py_None); resultobj = Py_None;
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj;
6404 wxCaret *arg1 = (wxCaret *) 0 ;
6405 bool result;
6406 PyObject * obj0 = 0 ;
6407 char *kwnames[] = {
6408 (char *) "self", NULL
6409 };
6410
6411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6413 if (SWIG_arg_fail(1)) SWIG_fail;
6414 {
6415 PyThreadState* __tstate = wxPyBeginAllowThreads();
6416 result = (bool)(arg1)->IsOk();
6417
6418 wxPyEndAllowThreads(__tstate);
6419 if (PyErr_Occurred()) SWIG_fail;
6420 }
6421 {
6422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6423 }
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6431 PyObject *resultobj;
6432 wxCaret *arg1 = (wxCaret *) 0 ;
6433 bool result;
6434 PyObject * obj0 = 0 ;
6435 char *kwnames[] = {
6436 (char *) "self", NULL
6437 };
6438
6439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6441 if (SWIG_arg_fail(1)) SWIG_fail;
6442 {
6443 PyThreadState* __tstate = wxPyBeginAllowThreads();
6444 result = (bool)(arg1)->IsVisible();
6445
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 {
6450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6451 }
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj;
6460 wxCaret *arg1 = (wxCaret *) 0 ;
6461 wxPoint result;
6462 PyObject * obj0 = 0 ;
6463 char *kwnames[] = {
6464 (char *) "self", NULL
6465 };
6466
6467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6469 if (SWIG_arg_fail(1)) SWIG_fail;
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 result = (arg1)->GetPosition();
6473
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 {
6478 wxPoint * resultptr;
6479 resultptr = new wxPoint((wxPoint &)(result));
6480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6481 }
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxCaret *arg1 = (wxCaret *) 0 ;
6491 int *arg2 = (int *) 0 ;
6492 int *arg3 = (int *) 0 ;
6493 int temp2 ;
6494 int res2 = 0 ;
6495 int temp3 ;
6496 int res3 = 0 ;
6497 PyObject * obj0 = 0 ;
6498 char *kwnames[] = {
6499 (char *) "self", NULL
6500 };
6501
6502 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6503 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6506 if (SWIG_arg_fail(1)) SWIG_fail;
6507 {
6508 PyThreadState* __tstate = wxPyBeginAllowThreads();
6509 (arg1)->GetPosition(arg2,arg3);
6510
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 Py_INCREF(Py_None); resultobj = Py_None;
6515 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6516 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6517 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6518 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6526 PyObject *resultobj;
6527 wxCaret *arg1 = (wxCaret *) 0 ;
6528 wxSize result;
6529 PyObject * obj0 = 0 ;
6530 char *kwnames[] = {
6531 (char *) "self", NULL
6532 };
6533
6534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",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 = (arg1)->GetSize();
6540
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 {
6545 wxSize * resultptr;
6546 resultptr = new wxSize((wxSize &)(result));
6547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6548 }
6549 return resultobj;
6550 fail:
6551 return NULL;
6552 }
6553
6554
6555 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj;
6557 wxCaret *arg1 = (wxCaret *) 0 ;
6558 int *arg2 = (int *) 0 ;
6559 int *arg3 = (int *) 0 ;
6560 int temp2 ;
6561 int res2 = 0 ;
6562 int temp3 ;
6563 int res3 = 0 ;
6564 PyObject * obj0 = 0 ;
6565 char *kwnames[] = {
6566 (char *) "self", NULL
6567 };
6568
6569 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6570 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6573 if (SWIG_arg_fail(1)) SWIG_fail;
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 (arg1)->GetSize(arg2,arg3);
6577
6578 wxPyEndAllowThreads(__tstate);
6579 if (PyErr_Occurred()) SWIG_fail;
6580 }
6581 Py_INCREF(Py_None); resultobj = Py_None;
6582 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6583 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6584 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6585 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
6592 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6593 PyObject *resultobj;
6594 wxCaret *arg1 = (wxCaret *) 0 ;
6595 wxWindow *result;
6596 PyObject * obj0 = 0 ;
6597 char *kwnames[] = {
6598 (char *) "self", NULL
6599 };
6600
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 result = (wxWindow *)(arg1)->GetWindow();
6607
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 {
6612 resultobj = wxPyMake_wxObject(result, 0);
6613 }
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj;
6622 wxCaret *arg1 = (wxCaret *) 0 ;
6623 int arg2 ;
6624 int arg3 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 PyObject * obj2 = 0 ;
6628 char *kwnames[] = {
6629 (char *) "self",(char *) "x",(char *) "y", NULL
6630 };
6631
6632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6634 if (SWIG_arg_fail(1)) SWIG_fail;
6635 {
6636 arg2 = (int)(SWIG_As_int(obj1));
6637 if (SWIG_arg_fail(2)) SWIG_fail;
6638 }
6639 {
6640 arg3 = (int)(SWIG_As_int(obj2));
6641 if (SWIG_arg_fail(3)) SWIG_fail;
6642 }
6643 {
6644 PyThreadState* __tstate = wxPyBeginAllowThreads();
6645 (arg1)->Move(arg2,arg3);
6646
6647 wxPyEndAllowThreads(__tstate);
6648 if (PyErr_Occurred()) SWIG_fail;
6649 }
6650 Py_INCREF(Py_None); resultobj = Py_None;
6651 return resultobj;
6652 fail:
6653 return NULL;
6654 }
6655
6656
6657 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6658 PyObject *resultobj;
6659 wxCaret *arg1 = (wxCaret *) 0 ;
6660 wxPoint *arg2 = 0 ;
6661 wxPoint temp2 ;
6662 PyObject * obj0 = 0 ;
6663 PyObject * obj1 = 0 ;
6664 char *kwnames[] = {
6665 (char *) "self",(char *) "pt", NULL
6666 };
6667
6668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6670 if (SWIG_arg_fail(1)) SWIG_fail;
6671 {
6672 arg2 = &temp2;
6673 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6674 }
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 (arg1)->Move((wxPoint const &)*arg2);
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 Py_INCREF(Py_None); resultobj = Py_None;
6683 return resultobj;
6684 fail:
6685 return NULL;
6686 }
6687
6688
6689 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6690 PyObject *resultobj;
6691 wxCaret *arg1 = (wxCaret *) 0 ;
6692 int arg2 ;
6693 int arg3 ;
6694 PyObject * obj0 = 0 ;
6695 PyObject * obj1 = 0 ;
6696 PyObject * obj2 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "self",(char *) "width",(char *) "height", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 arg2 = (int)(SWIG_As_int(obj1));
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 arg3 = (int)(SWIG_As_int(obj2));
6710 if (SWIG_arg_fail(3)) SWIG_fail;
6711 }
6712 {
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 (arg1)->SetSize(arg2,arg3);
6715
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 Py_INCREF(Py_None); resultobj = Py_None;
6720 return resultobj;
6721 fail:
6722 return NULL;
6723 }
6724
6725
6726 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6727 PyObject *resultobj;
6728 wxCaret *arg1 = (wxCaret *) 0 ;
6729 wxSize *arg2 = 0 ;
6730 wxSize temp2 ;
6731 PyObject * obj0 = 0 ;
6732 PyObject * obj1 = 0 ;
6733 char *kwnames[] = {
6734 (char *) "self",(char *) "size", NULL
6735 };
6736
6737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6739 if (SWIG_arg_fail(1)) SWIG_fail;
6740 {
6741 arg2 = &temp2;
6742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6743 }
6744 {
6745 PyThreadState* __tstate = wxPyBeginAllowThreads();
6746 (arg1)->SetSize((wxSize const &)*arg2);
6747
6748 wxPyEndAllowThreads(__tstate);
6749 if (PyErr_Occurred()) SWIG_fail;
6750 }
6751 Py_INCREF(Py_None); resultobj = Py_None;
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6759 PyObject *resultobj;
6760 wxCaret *arg1 = (wxCaret *) 0 ;
6761 int arg2 = (int) true ;
6762 PyObject * obj0 = 0 ;
6763 PyObject * obj1 = 0 ;
6764 char *kwnames[] = {
6765 (char *) "self",(char *) "show", NULL
6766 };
6767
6768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6770 if (SWIG_arg_fail(1)) SWIG_fail;
6771 if (obj1) {
6772 {
6773 arg2 = (int)(SWIG_As_int(obj1));
6774 if (SWIG_arg_fail(2)) SWIG_fail;
6775 }
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 (arg1)->Show(arg2);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 Py_INCREF(Py_None); resultobj = Py_None;
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj;
6793 wxCaret *arg1 = (wxCaret *) 0 ;
6794 PyObject * obj0 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 PyThreadState* __tstate = wxPyBeginAllowThreads();
6804 (arg1)->Hide();
6805
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 Py_INCREF(Py_None); resultobj = Py_None;
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj;
6818 int result;
6819 char *kwnames[] = {
6820 NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6824 {
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)wxCaret::GetBlinkTime();
6827
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 {
6832 resultobj = SWIG_From_int((int)(result));
6833 }
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6841 PyObject *resultobj;
6842 int arg1 ;
6843 PyObject * obj0 = 0 ;
6844 char *kwnames[] = {
6845 (char *) "milliseconds", NULL
6846 };
6847
6848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6849 {
6850 arg1 = (int)(SWIG_As_int(obj0));
6851 if (SWIG_arg_fail(1)) SWIG_fail;
6852 }
6853 {
6854 PyThreadState* __tstate = wxPyBeginAllowThreads();
6855 wxCaret::SetBlinkTime(arg1);
6856
6857 wxPyEndAllowThreads(__tstate);
6858 if (PyErr_Occurred()) SWIG_fail;
6859 }
6860 Py_INCREF(Py_None); resultobj = Py_None;
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6868 PyObject *obj;
6869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6870 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6871 Py_INCREF(obj);
6872 return Py_BuildValue((char *)"");
6873 }
6874 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6877 wxBusyCursor *result;
6878 PyObject * obj0 = 0 ;
6879 char *kwnames[] = {
6880 (char *) "cursor", NULL
6881 };
6882
6883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6884 if (obj0) {
6885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6886 if (SWIG_arg_fail(1)) SWIG_fail;
6887 }
6888 {
6889 if (!wxPyCheckForApp()) SWIG_fail;
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6904 PyObject *resultobj;
6905 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6906 PyObject * obj0 = 0 ;
6907 char *kwnames[] = {
6908 (char *) "self", NULL
6909 };
6910
6911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6913 if (SWIG_arg_fail(1)) SWIG_fail;
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 delete arg1;
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 Py_INCREF(Py_None); resultobj = Py_None;
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6929 PyObject *obj;
6930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6931 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6932 Py_INCREF(obj);
6933 return Py_BuildValue((char *)"");
6934 }
6935 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj;
6937 wxWindow *arg1 = (wxWindow *) NULL ;
6938 wxWindowDisabler *result;
6939 PyObject * obj0 = 0 ;
6940 char *kwnames[] = {
6941 (char *) "winToSkip", NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6945 if (obj0) {
6946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6947 if (SWIG_arg_fail(1)) SWIG_fail;
6948 }
6949 {
6950 if (!wxPyCheckForApp()) SWIG_fail;
6951 PyThreadState* __tstate = wxPyBeginAllowThreads();
6952 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6953
6954 wxPyEndAllowThreads(__tstate);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6965 PyObject *resultobj;
6966 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6967 PyObject * obj0 = 0 ;
6968 char *kwnames[] = {
6969 (char *) "self", NULL
6970 };
6971
6972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6974 if (SWIG_arg_fail(1)) SWIG_fail;
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 delete arg1;
6978
6979 wxPyEndAllowThreads(__tstate);
6980 if (PyErr_Occurred()) SWIG_fail;
6981 }
6982 Py_INCREF(Py_None); resultobj = Py_None;
6983 return resultobj;
6984 fail:
6985 return NULL;
6986 }
6987
6988
6989 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6990 PyObject *obj;
6991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6992 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6993 Py_INCREF(obj);
6994 return Py_BuildValue((char *)"");
6995 }
6996 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj;
6998 wxString *arg1 = 0 ;
6999 wxBusyInfo *result;
7000 bool temp1 = false ;
7001 PyObject * obj0 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "message", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7007 {
7008 arg1 = wxString_in_helper(obj0);
7009 if (arg1 == NULL) SWIG_fail;
7010 temp1 = true;
7011 }
7012 {
7013 if (!wxPyCheckForApp()) SWIG_fail;
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7021 {
7022 if (temp1)
7023 delete arg1;
7024 }
7025 return resultobj;
7026 fail:
7027 {
7028 if (temp1)
7029 delete arg1;
7030 }
7031 return NULL;
7032 }
7033
7034
7035 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj;
7037 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7038 PyObject * obj0 = 0 ;
7039 char *kwnames[] = {
7040 (char *) "self", NULL
7041 };
7042
7043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7045 if (SWIG_arg_fail(1)) SWIG_fail;
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 delete arg1;
7049
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 Py_INCREF(Py_None); resultobj = Py_None;
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7061 PyObject *obj;
7062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7063 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7064 Py_INCREF(obj);
7065 return Py_BuildValue((char *)"");
7066 }
7067 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj;
7069 wxStopWatch *result;
7070 char *kwnames[] = {
7071 NULL
7072 };
7073
7074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7075 {
7076 PyThreadState* __tstate = wxPyBeginAllowThreads();
7077 result = (wxStopWatch *)new wxStopWatch();
7078
7079 wxPyEndAllowThreads(__tstate);
7080 if (PyErr_Occurred()) SWIG_fail;
7081 }
7082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7092 long arg2 = (long) 0 ;
7093 PyObject * obj0 = 0 ;
7094 PyObject * obj1 = 0 ;
7095 char *kwnames[] = {
7096 (char *) "self",(char *) "t0", NULL
7097 };
7098
7099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7101 if (SWIG_arg_fail(1)) SWIG_fail;
7102 if (obj1) {
7103 {
7104 arg2 = (long)(SWIG_As_long(obj1));
7105 if (SWIG_arg_fail(2)) SWIG_fail;
7106 }
7107 }
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 (arg1)->Start(arg2);
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 Py_INCREF(Py_None); resultobj = Py_None;
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 (arg1)->Pause();
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 Py_INCREF(Py_None); resultobj = Py_None;
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj;
7149 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7150 PyObject * obj0 = 0 ;
7151 char *kwnames[] = {
7152 (char *) "self", NULL
7153 };
7154
7155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7157 if (SWIG_arg_fail(1)) SWIG_fail;
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 (arg1)->Resume();
7161
7162 wxPyEndAllowThreads(__tstate);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 Py_INCREF(Py_None); resultobj = Py_None;
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj;
7174 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7175 long result;
7176 PyObject * obj0 = 0 ;
7177 char *kwnames[] = {
7178 (char *) "self", NULL
7179 };
7180
7181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7183 if (SWIG_arg_fail(1)) SWIG_fail;
7184 {
7185 PyThreadState* __tstate = wxPyBeginAllowThreads();
7186 result = (long)((wxStopWatch const *)arg1)->Time();
7187
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 {
7192 resultobj = SWIG_From_long((long)(result));
7193 }
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7201 PyObject *obj;
7202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7203 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7204 Py_INCREF(obj);
7205 return Py_BuildValue((char *)"");
7206 }
7207 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 int arg1 = (int) 9 ;
7210 int arg2 = (int) wxID_FILE1 ;
7211 wxFileHistory *result;
7212 PyObject * obj0 = 0 ;
7213 PyObject * obj1 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "maxFiles",(char *) "idBase", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7219 if (obj0) {
7220 {
7221 arg1 = (int)(SWIG_As_int(obj0));
7222 if (SWIG_arg_fail(1)) SWIG_fail;
7223 }
7224 }
7225 if (obj1) {
7226 {
7227 arg2 = (int)(SWIG_As_int(obj1));
7228 if (SWIG_arg_fail(2)) SWIG_fail;
7229 }
7230 }
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj;
7247 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 delete arg1;
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_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj;
7272 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7273 wxString *arg2 = 0 ;
7274 bool temp2 = false ;
7275 PyObject * obj0 = 0 ;
7276 PyObject * obj1 = 0 ;
7277 char *kwnames[] = {
7278 (char *) "self",(char *) "file", NULL
7279 };
7280
7281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7283 if (SWIG_arg_fail(1)) SWIG_fail;
7284 {
7285 arg2 = wxString_in_helper(obj1);
7286 if (arg2 == NULL) SWIG_fail;
7287 temp2 = true;
7288 }
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 (arg1)->AddFileToHistory((wxString const &)*arg2);
7292
7293 wxPyEndAllowThreads(__tstate);
7294 if (PyErr_Occurred()) SWIG_fail;
7295 }
7296 Py_INCREF(Py_None); resultobj = Py_None;
7297 {
7298 if (temp2)
7299 delete arg2;
7300 }
7301 return resultobj;
7302 fail:
7303 {
7304 if (temp2)
7305 delete arg2;
7306 }
7307 return NULL;
7308 }
7309
7310
7311 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7312 PyObject *resultobj;
7313 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7314 int arg2 ;
7315 PyObject * obj0 = 0 ;
7316 PyObject * obj1 = 0 ;
7317 char *kwnames[] = {
7318 (char *) "self",(char *) "i", NULL
7319 };
7320
7321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7323 if (SWIG_arg_fail(1)) SWIG_fail;
7324 {
7325 arg2 = (int)(SWIG_As_int(obj1));
7326 if (SWIG_arg_fail(2)) SWIG_fail;
7327 }
7328 {
7329 PyThreadState* __tstate = wxPyBeginAllowThreads();
7330 (arg1)->RemoveFileFromHistory(arg2);
7331
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 Py_INCREF(Py_None); resultobj = Py_None;
7336 return resultobj;
7337 fail:
7338 return NULL;
7339 }
7340
7341
7342 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7343 PyObject *resultobj;
7344 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7345 int result;
7346 PyObject * obj0 = 0 ;
7347 char *kwnames[] = {
7348 (char *) "self", NULL
7349 };
7350
7351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7353 if (SWIG_arg_fail(1)) SWIG_fail;
7354 {
7355 PyThreadState* __tstate = wxPyBeginAllowThreads();
7356 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7357
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = SWIG_From_int((int)(result));
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj;
7372 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7373 wxMenu *arg2 = (wxMenu *) 0 ;
7374 PyObject * obj0 = 0 ;
7375 PyObject * obj1 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "self",(char *) "menu", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7382 if (SWIG_arg_fail(1)) SWIG_fail;
7383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(2)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->UseMenu(arg2);
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7402 wxMenu *arg2 = (wxMenu *) 0 ;
7403 PyObject * obj0 = 0 ;
7404 PyObject * obj1 = 0 ;
7405 char *kwnames[] = {
7406 (char *) "self",(char *) "menu", NULL
7407 };
7408
7409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7411 if (SWIG_arg_fail(1)) SWIG_fail;
7412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(2)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->RemoveMenu(arg2);
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7431 wxConfigBase *arg2 = 0 ;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self",(char *) "config", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 {
7442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7443 if (SWIG_arg_fail(2)) SWIG_fail;
7444 if (arg2 == NULL) {
7445 SWIG_null_ref("wxConfigBase");
7446 }
7447 if (SWIG_arg_fail(2)) SWIG_fail;
7448 }
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 (arg1)->Load(*arg2);
7452
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 Py_INCREF(Py_None); resultobj = Py_None;
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj;
7465 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7466 wxConfigBase *arg2 = 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self",(char *) "config", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 {
7477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7478 if (SWIG_arg_fail(2)) SWIG_fail;
7479 if (arg2 == NULL) {
7480 SWIG_null_ref("wxConfigBase");
7481 }
7482 if (SWIG_arg_fail(2)) SWIG_fail;
7483 }
7484 {
7485 PyThreadState* __tstate = wxPyBeginAllowThreads();
7486 (arg1)->Save(*arg2);
7487
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 Py_INCREF(Py_None); resultobj = Py_None;
7492 return resultobj;
7493 fail:
7494 return NULL;
7495 }
7496
7497
7498 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7499 PyObject *resultobj;
7500 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7501 PyObject * obj0 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "self", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7508 if (SWIG_arg_fail(1)) SWIG_fail;
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 (arg1)->AddFilesToMenu();
7512
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 Py_INCREF(Py_None); resultobj = Py_None;
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj;
7525 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7526 wxMenu *arg2 = (wxMenu *) 0 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char *kwnames[] = {
7530 (char *) "self",(char *) "menu", NULL
7531 };
7532
7533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7535 if (SWIG_arg_fail(1)) SWIG_fail;
7536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 {
7539 PyThreadState* __tstate = wxPyBeginAllowThreads();
7540 (arg1)->AddFilesToMenu(arg2);
7541
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 Py_INCREF(Py_None); resultobj = Py_None;
7546 return resultobj;
7547 fail:
7548 return NULL;
7549 }
7550
7551
7552 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7553 PyObject *resultobj;
7554 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7555 int arg2 ;
7556 wxString result;
7557 PyObject * obj0 = 0 ;
7558 PyObject * obj1 = 0 ;
7559 char *kwnames[] = {
7560 (char *) "self",(char *) "i", NULL
7561 };
7562
7563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7565 if (SWIG_arg_fail(1)) SWIG_fail;
7566 {
7567 arg2 = (int)(SWIG_As_int(obj1));
7568 if (SWIG_arg_fail(2)) SWIG_fail;
7569 }
7570 {
7571 PyThreadState* __tstate = wxPyBeginAllowThreads();
7572 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7573
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 {
7578 #if wxUSE_UNICODE
7579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7580 #else
7581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7582 #endif
7583 }
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj;
7592 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7593 int result;
7594 PyObject * obj0 = 0 ;
7595 char *kwnames[] = {
7596 (char *) "self", NULL
7597 };
7598
7599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7601 if (SWIG_arg_fail(1)) SWIG_fail;
7602 {
7603 PyThreadState* __tstate = wxPyBeginAllowThreads();
7604 result = (int)((wxFileHistory const *)arg1)->GetCount();
7605
7606 wxPyEndAllowThreads(__tstate);
7607 if (PyErr_Occurred()) SWIG_fail;
7608 }
7609 {
7610 resultobj = SWIG_From_int((int)(result));
7611 }
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7619 PyObject *obj;
7620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7621 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7622 Py_INCREF(obj);
7623 return Py_BuildValue((char *)"");
7624 }
7625 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj;
7627 wxString *arg1 = 0 ;
7628 wxString const &arg2_defvalue = wxPyEmptyString ;
7629 wxString *arg2 = (wxString *) &arg2_defvalue ;
7630 wxSingleInstanceChecker *result;
7631 bool temp1 = false ;
7632 bool temp2 = false ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 char *kwnames[] = {
7636 (char *) "name",(char *) "path", NULL
7637 };
7638
7639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7640 {
7641 arg1 = wxString_in_helper(obj0);
7642 if (arg1 == NULL) SWIG_fail;
7643 temp1 = true;
7644 }
7645 if (obj1) {
7646 {
7647 arg2 = wxString_in_helper(obj1);
7648 if (arg2 == NULL) SWIG_fail;
7649 temp2 = true;
7650 }
7651 }
7652 {
7653 PyThreadState* __tstate = wxPyBeginAllowThreads();
7654 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7655
7656 wxPyEndAllowThreads(__tstate);
7657 if (PyErr_Occurred()) SWIG_fail;
7658 }
7659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7660 {
7661 if (temp1)
7662 delete arg1;
7663 }
7664 {
7665 if (temp2)
7666 delete arg2;
7667 }
7668 return resultobj;
7669 fail:
7670 {
7671 if (temp1)
7672 delete arg1;
7673 }
7674 {
7675 if (temp2)
7676 delete arg2;
7677 }
7678 return NULL;
7679 }
7680
7681
7682 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj;
7684 wxSingleInstanceChecker *result;
7685 char *kwnames[] = {
7686 NULL
7687 };
7688
7689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7707 PyObject * obj0 = 0 ;
7708 char *kwnames[] = {
7709 (char *) "self", NULL
7710 };
7711
7712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7714 if (SWIG_arg_fail(1)) SWIG_fail;
7715 {
7716 PyThreadState* __tstate = wxPyBeginAllowThreads();
7717 delete arg1;
7718
7719 wxPyEndAllowThreads(__tstate);
7720 if (PyErr_Occurred()) SWIG_fail;
7721 }
7722 Py_INCREF(Py_None); resultobj = Py_None;
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7730 PyObject *resultobj;
7731 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7732 wxString *arg2 = 0 ;
7733 wxString const &arg3_defvalue = wxPyEmptyString ;
7734 wxString *arg3 = (wxString *) &arg3_defvalue ;
7735 bool result;
7736 bool temp2 = false ;
7737 bool temp3 = false ;
7738 PyObject * obj0 = 0 ;
7739 PyObject * obj1 = 0 ;
7740 PyObject * obj2 = 0 ;
7741 char *kwnames[] = {
7742 (char *) "self",(char *) "name",(char *) "path", NULL
7743 };
7744
7745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7747 if (SWIG_arg_fail(1)) SWIG_fail;
7748 {
7749 arg2 = wxString_in_helper(obj1);
7750 if (arg2 == NULL) SWIG_fail;
7751 temp2 = true;
7752 }
7753 if (obj2) {
7754 {
7755 arg3 = wxString_in_helper(obj2);
7756 if (arg3 == NULL) SWIG_fail;
7757 temp3 = true;
7758 }
7759 }
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7763
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769 }
7770 {
7771 if (temp2)
7772 delete arg2;
7773 }
7774 {
7775 if (temp3)
7776 delete arg3;
7777 }
7778 return resultobj;
7779 fail:
7780 {
7781 if (temp2)
7782 delete arg2;
7783 }
7784 {
7785 if (temp3)
7786 delete arg3;
7787 }
7788 return NULL;
7789 }
7790
7791
7792 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7793 PyObject *resultobj;
7794 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7795 bool result;
7796 PyObject * obj0 = 0 ;
7797 char *kwnames[] = {
7798 (char *) "self", NULL
7799 };
7800
7801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7807
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 {
7812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7813 }
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7821 PyObject *obj;
7822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7823 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7824 Py_INCREF(obj);
7825 return Py_BuildValue((char *)"");
7826 }
7827 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj;
7829 wxWindow *arg1 = (wxWindow *) 0 ;
7830 wxDC *arg2 = 0 ;
7831 bool result;
7832 PyObject * obj0 = 0 ;
7833 PyObject * obj1 = 0 ;
7834 char *kwnames[] = {
7835 (char *) "window",(char *) "dc", NULL
7836 };
7837
7838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7840 if (SWIG_arg_fail(1)) SWIG_fail;
7841 {
7842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7843 if (SWIG_arg_fail(2)) SWIG_fail;
7844 if (arg2 == NULL) {
7845 SWIG_null_ref("wxDC");
7846 }
7847 if (SWIG_arg_fail(2)) SWIG_fail;
7848 }
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj;
7867 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7868 PyObject * obj0 = 0 ;
7869 char *kwnames[] = {
7870 (char *) "self", NULL
7871 };
7872
7873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7875 if (SWIG_arg_fail(1)) SWIG_fail;
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 delete arg1;
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 Py_INCREF(Py_None); resultobj = Py_None;
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj;
7892 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7893 wxString result;
7894 PyObject * obj0 = 0 ;
7895 char *kwnames[] = {
7896 (char *) "self", NULL
7897 };
7898
7899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7901 if (SWIG_arg_fail(1)) SWIG_fail;
7902 {
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 result = (arg1)->GetTip();
7905
7906 wxPyEndAllowThreads(__tstate);
7907 if (PyErr_Occurred()) SWIG_fail;
7908 }
7909 {
7910 #if wxUSE_UNICODE
7911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7912 #else
7913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7914 #endif
7915 }
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj;
7924 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7925 size_t result;
7926 PyObject * obj0 = 0 ;
7927 char *kwnames[] = {
7928 (char *) "self", NULL
7929 };
7930
7931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7933 if (SWIG_arg_fail(1)) SWIG_fail;
7934 {
7935 PyThreadState* __tstate = wxPyBeginAllowThreads();
7936 result = (size_t)(arg1)->GetCurrentTip();
7937
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 {
7942 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7943 }
7944 return resultobj;
7945 fail:
7946 return NULL;
7947 }
7948
7949
7950 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7951 PyObject *resultobj;
7952 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7953 wxString *arg2 = 0 ;
7954 wxString result;
7955 bool temp2 = false ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char *kwnames[] = {
7959 (char *) "self",(char *) "tip", NULL
7960 };
7961
7962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7964 if (SWIG_arg_fail(1)) SWIG_fail;
7965 {
7966 arg2 = wxString_in_helper(obj1);
7967 if (arg2 == NULL) SWIG_fail;
7968 temp2 = true;
7969 }
7970 {
7971 PyThreadState* __tstate = wxPyBeginAllowThreads();
7972 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7973
7974 wxPyEndAllowThreads(__tstate);
7975 if (PyErr_Occurred()) SWIG_fail;
7976 }
7977 {
7978 #if wxUSE_UNICODE
7979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7980 #else
7981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7982 #endif
7983 }
7984 {
7985 if (temp2)
7986 delete arg2;
7987 }
7988 return resultobj;
7989 fail:
7990 {
7991 if (temp2)
7992 delete arg2;
7993 }
7994 return NULL;
7995 }
7996
7997
7998 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7999 PyObject *obj;
8000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8001 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8002 Py_INCREF(obj);
8003 return Py_BuildValue((char *)"");
8004 }
8005 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj;
8007 size_t arg1 ;
8008 wxPyTipProvider *result;
8009 PyObject * obj0 = 0 ;
8010 char *kwnames[] = {
8011 (char *) "currentTip", NULL
8012 };
8013
8014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8015 {
8016 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8017 if (SWIG_arg_fail(1)) SWIG_fail;
8018 }
8019 {
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8022
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj;
8035 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8036 PyObject *arg2 = (PyObject *) 0 ;
8037 PyObject *arg3 = (PyObject *) 0 ;
8038 PyObject * obj0 = 0 ;
8039 PyObject * obj1 = 0 ;
8040 PyObject * obj2 = 0 ;
8041 char *kwnames[] = {
8042 (char *) "self",(char *) "self",(char *) "_class", NULL
8043 };
8044
8045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8047 if (SWIG_arg_fail(1)) SWIG_fail;
8048 arg2 = obj1;
8049 arg3 = obj2;
8050 {
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 (arg1)->_setCallbackInfo(arg2,arg3);
8053
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 Py_INCREF(Py_None); resultobj = Py_None;
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8065 PyObject *obj;
8066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8067 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8068 Py_INCREF(obj);
8069 return Py_BuildValue((char *)"");
8070 }
8071 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj;
8073 wxWindow *arg1 = (wxWindow *) 0 ;
8074 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8075 bool arg3 = (bool) true ;
8076 bool result;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 PyObject * obj2 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8088 if (SWIG_arg_fail(2)) SWIG_fail;
8089 if (obj2) {
8090 {
8091 arg3 = (bool)(SWIG_As_bool(obj2));
8092 if (SWIG_arg_fail(3)) SWIG_fail;
8093 }
8094 }
8095 {
8096 if (!wxPyCheckForApp()) SWIG_fail;
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 result = (bool)wxShowTip(arg1,arg2,arg3);
8099
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 {
8104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8113 PyObject *resultobj;
8114 wxString *arg1 = 0 ;
8115 size_t arg2 ;
8116 wxTipProvider *result;
8117 bool temp1 = false ;
8118 PyObject * obj0 = 0 ;
8119 PyObject * obj1 = 0 ;
8120 char *kwnames[] = {
8121 (char *) "filename",(char *) "currentTip", NULL
8122 };
8123
8124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8125 {
8126 arg1 = wxString_in_helper(obj0);
8127 if (arg1 == NULL) SWIG_fail;
8128 temp1 = true;
8129 }
8130 {
8131 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8132 if (SWIG_arg_fail(2)) SWIG_fail;
8133 }
8134 {
8135 if (!wxPyCheckForApp()) SWIG_fail;
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8138
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8143 {
8144 if (temp1)
8145 delete arg1;
8146 }
8147 return resultobj;
8148 fail:
8149 {
8150 if (temp1)
8151 delete arg1;
8152 }
8153 return NULL;
8154 }
8155
8156
8157 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8158 PyObject *resultobj;
8159 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8160 int arg2 = (int) -1 ;
8161 wxPyTimer *result;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 char *kwnames[] = {
8165 (char *) "owner",(char *) "id", NULL
8166 };
8167
8168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8169 if (obj0) {
8170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8171 if (SWIG_arg_fail(1)) SWIG_fail;
8172 }
8173 if (obj1) {
8174 {
8175 arg2 = (int)(SWIG_As_int(obj1));
8176 if (SWIG_arg_fail(2)) SWIG_fail;
8177 }
8178 }
8179 {
8180 if (!wxPyCheckForApp()) SWIG_fail;
8181 PyThreadState* __tstate = wxPyBeginAllowThreads();
8182 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8183
8184 wxPyEndAllowThreads(__tstate);
8185 if (PyErr_Occurred()) SWIG_fail;
8186 }
8187 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj;
8196 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8197 PyObject * obj0 = 0 ;
8198 char *kwnames[] = {
8199 (char *) "self", NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8204 if (SWIG_arg_fail(1)) SWIG_fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 delete arg1;
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 Py_INCREF(Py_None); resultobj = Py_None;
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj;
8221 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8222 PyObject *arg2 = (PyObject *) 0 ;
8223 PyObject *arg3 = (PyObject *) 0 ;
8224 int arg4 = (int) 1 ;
8225 PyObject * obj0 = 0 ;
8226 PyObject * obj1 = 0 ;
8227 PyObject * obj2 = 0 ;
8228 PyObject * obj3 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 arg2 = obj1;
8237 arg3 = obj2;
8238 if (obj3) {
8239 {
8240 arg4 = (int)(SWIG_As_int(obj3));
8241 if (SWIG_arg_fail(4)) SWIG_fail;
8242 }
8243 }
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 Py_INCREF(Py_None); resultobj = Py_None;
8252 return resultobj;
8253 fail:
8254 return NULL;
8255 }
8256
8257
8258 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8261 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8262 int arg3 = (int) -1 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 PyObject * obj2 = 0 ;
8266 char *kwnames[] = {
8267 (char *) "self",(char *) "owner",(char *) "id", NULL
8268 };
8269
8270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8272 if (SWIG_arg_fail(1)) SWIG_fail;
8273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(2)) SWIG_fail;
8275 if (obj2) {
8276 {
8277 arg3 = (int)(SWIG_As_int(obj2));
8278 if (SWIG_arg_fail(3)) SWIG_fail;
8279 }
8280 }
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 (arg1)->SetOwner(arg2,arg3);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 Py_INCREF(Py_None); resultobj = Py_None;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj;
8297 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8298 wxEvtHandler *result;
8299 PyObject * obj0 = 0 ;
8300 char *kwnames[] = {
8301 (char *) "self", NULL
8302 };
8303
8304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8306 if (SWIG_arg_fail(1)) SWIG_fail;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 result = (wxEvtHandler *)(arg1)->GetOwner();
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 {
8315 resultobj = wxPyMake_wxObject(result, 0);
8316 }
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj;
8325 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8326 int arg2 = (int) -1 ;
8327 bool arg3 = (bool) false ;
8328 bool result;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 PyObject * obj2 = 0 ;
8332 char *kwnames[] = {
8333 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8334 };
8335
8336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8338 if (SWIG_arg_fail(1)) SWIG_fail;
8339 if (obj1) {
8340 {
8341 arg2 = (int)(SWIG_As_int(obj1));
8342 if (SWIG_arg_fail(2)) SWIG_fail;
8343 }
8344 }
8345 if (obj2) {
8346 {
8347 arg3 = (bool)(SWIG_As_bool(obj2));
8348 if (SWIG_arg_fail(3)) SWIG_fail;
8349 }
8350 }
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 result = (bool)(arg1)->Start(arg2,arg3);
8354
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 {
8359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8360 }
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8368 PyObject *resultobj;
8369 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8370 PyObject * obj0 = 0 ;
8371 char *kwnames[] = {
8372 (char *) "self", NULL
8373 };
8374
8375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8377 if (SWIG_arg_fail(1)) SWIG_fail;
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 (arg1)->Stop();
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 Py_INCREF(Py_None); resultobj = Py_None;
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj;
8394 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8395 bool result;
8396 PyObject * obj0 = 0 ;
8397 char *kwnames[] = {
8398 (char *) "self", NULL
8399 };
8400
8401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8403 if (SWIG_arg_fail(1)) SWIG_fail;
8404 {
8405 PyThreadState* __tstate = wxPyBeginAllowThreads();
8406 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8407
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 {
8412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8413 }
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8421 PyObject *resultobj;
8422 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8423 int result;
8424 PyObject * obj0 = 0 ;
8425 char *kwnames[] = {
8426 (char *) "self", NULL
8427 };
8428
8429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8431 if (SWIG_arg_fail(1)) SWIG_fail;
8432 {
8433 PyThreadState* __tstate = wxPyBeginAllowThreads();
8434 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8435
8436 wxPyEndAllowThreads(__tstate);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 {
8440 resultobj = SWIG_From_int((int)(result));
8441 }
8442 return resultobj;
8443 fail:
8444 return NULL;
8445 }
8446
8447
8448 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8449 PyObject *resultobj;
8450 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8451 bool result;
8452 PyObject * obj0 = 0 ;
8453 char *kwnames[] = {
8454 (char *) "self", NULL
8455 };
8456
8457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8459 if (SWIG_arg_fail(1)) SWIG_fail;
8460 {
8461 PyThreadState* __tstate = wxPyBeginAllowThreads();
8462 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8463
8464 wxPyEndAllowThreads(__tstate);
8465 if (PyErr_Occurred()) SWIG_fail;
8466 }
8467 {
8468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8469 }
8470 return resultobj;
8471 fail:
8472 return NULL;
8473 }
8474
8475
8476 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8477 PyObject *resultobj;
8478 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8479 int result;
8480 PyObject * obj0 = 0 ;
8481 char *kwnames[] = {
8482 (char *) "self", NULL
8483 };
8484
8485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8487 if (SWIG_arg_fail(1)) SWIG_fail;
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (int)((wxPyTimer const *)arg1)->GetId();
8491
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 {
8496 resultobj = SWIG_From_int((int)(result));
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8505 PyObject *obj;
8506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8507 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8508 Py_INCREF(obj);
8509 return Py_BuildValue((char *)"");
8510 }
8511 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 int arg1 = (int) 0 ;
8514 int arg2 = (int) 0 ;
8515 wxTimerEvent *result;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char *kwnames[] = {
8519 (char *) "timerid",(char *) "interval", NULL
8520 };
8521
8522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8523 if (obj0) {
8524 {
8525 arg1 = (int)(SWIG_As_int(obj0));
8526 if (SWIG_arg_fail(1)) SWIG_fail;
8527 }
8528 }
8529 if (obj1) {
8530 {
8531 arg2 = (int)(SWIG_As_int(obj1));
8532 if (SWIG_arg_fail(2)) SWIG_fail;
8533 }
8534 }
8535 {
8536 PyThreadState* __tstate = wxPyBeginAllowThreads();
8537 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8538
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8543 return resultobj;
8544 fail:
8545 return NULL;
8546 }
8547
8548
8549 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8550 PyObject *resultobj;
8551 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8552 int result;
8553 PyObject * obj0 = 0 ;
8554 char *kwnames[] = {
8555 (char *) "self", NULL
8556 };
8557
8558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8560 if (SWIG_arg_fail(1)) SWIG_fail;
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8564
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 resultobj = SWIG_From_int((int)(result));
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8578 PyObject *obj;
8579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8580 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8581 Py_INCREF(obj);
8582 return Py_BuildValue((char *)"");
8583 }
8584 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8585 PyObject *resultobj;
8586 wxTimer *arg1 = 0 ;
8587 wxTimerRunner *result;
8588 PyObject * obj0 = 0 ;
8589
8590 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8591 {
8592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8593 if (SWIG_arg_fail(1)) SWIG_fail;
8594 if (arg1 == NULL) {
8595 SWIG_null_ref("wxTimer");
8596 }
8597 if (SWIG_arg_fail(1)) SWIG_fail;
8598 }
8599 {
8600 if (!wxPyCheckForApp()) SWIG_fail;
8601 PyThreadState* __tstate = wxPyBeginAllowThreads();
8602 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8603
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8615 PyObject *resultobj;
8616 wxTimer *arg1 = 0 ;
8617 int arg2 ;
8618 bool arg3 = (bool) false ;
8619 wxTimerRunner *result;
8620 PyObject * obj0 = 0 ;
8621 PyObject * obj1 = 0 ;
8622 PyObject * obj2 = 0 ;
8623
8624 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8625 {
8626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8627 if (SWIG_arg_fail(1)) SWIG_fail;
8628 if (arg1 == NULL) {
8629 SWIG_null_ref("wxTimer");
8630 }
8631 if (SWIG_arg_fail(1)) SWIG_fail;
8632 }
8633 {
8634 arg2 = (int)(SWIG_As_int(obj1));
8635 if (SWIG_arg_fail(2)) SWIG_fail;
8636 }
8637 if (obj2) {
8638 {
8639 arg3 = (bool)(SWIG_As_bool(obj2));
8640 if (SWIG_arg_fail(3)) SWIG_fail;
8641 }
8642 }
8643 {
8644 if (!wxPyCheckForApp()) SWIG_fail;
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8647
8648 wxPyEndAllowThreads(__tstate);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8659 int argc;
8660 PyObject *argv[4];
8661 int ii;
8662
8663 argc = PyObject_Length(args);
8664 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8665 argv[ii] = PyTuple_GetItem(args,ii);
8666 }
8667 if (argc == 1) {
8668 int _v;
8669 {
8670 void *ptr = 0;
8671 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8672 _v = 0;
8673 PyErr_Clear();
8674 } else {
8675 _v = (ptr != 0);
8676 }
8677 }
8678 if (_v) {
8679 return _wrap_new_TimerRunner__SWIG_0(self,args);
8680 }
8681 }
8682 if ((argc >= 2) && (argc <= 3)) {
8683 int _v;
8684 {
8685 void *ptr = 0;
8686 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8687 _v = 0;
8688 PyErr_Clear();
8689 } else {
8690 _v = (ptr != 0);
8691 }
8692 }
8693 if (_v) {
8694 _v = SWIG_Check_int(argv[1]);
8695 if (_v) {
8696 if (argc <= 2) {
8697 return _wrap_new_TimerRunner__SWIG_1(self,args);
8698 }
8699 _v = SWIG_Check_bool(argv[2]);
8700 if (_v) {
8701 return _wrap_new_TimerRunner__SWIG_1(self,args);
8702 }
8703 }
8704 }
8705 }
8706
8707 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8708 return NULL;
8709 }
8710
8711
8712 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8713 PyObject *resultobj;
8714 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8715 PyObject * obj0 = 0 ;
8716 char *kwnames[] = {
8717 (char *) "self", NULL
8718 };
8719
8720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8722 if (SWIG_arg_fail(1)) SWIG_fail;
8723 {
8724 PyThreadState* __tstate = wxPyBeginAllowThreads();
8725 delete arg1;
8726
8727 wxPyEndAllowThreads(__tstate);
8728 if (PyErr_Occurred()) SWIG_fail;
8729 }
8730 Py_INCREF(Py_None); resultobj = Py_None;
8731 return resultobj;
8732 fail:
8733 return NULL;
8734 }
8735
8736
8737 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8738 PyObject *resultobj;
8739 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8740 int arg2 ;
8741 bool arg3 = (bool) false ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 PyObject * obj2 = 0 ;
8745 char *kwnames[] = {
8746 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8747 };
8748
8749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8751 if (SWIG_arg_fail(1)) SWIG_fail;
8752 {
8753 arg2 = (int)(SWIG_As_int(obj1));
8754 if (SWIG_arg_fail(2)) SWIG_fail;
8755 }
8756 if (obj2) {
8757 {
8758 arg3 = (bool)(SWIG_As_bool(obj2));
8759 if (SWIG_arg_fail(3)) SWIG_fail;
8760 }
8761 }
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 (arg1)->Start(arg2,arg3);
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 Py_INCREF(Py_None); resultobj = Py_None;
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8777 PyObject *obj;
8778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8779 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8780 Py_INCREF(obj);
8781 return Py_BuildValue((char *)"");
8782 }
8783 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj;
8785 wxLog *result;
8786 char *kwnames[] = {
8787 NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8791 {
8792 PyThreadState* __tstate = wxPyBeginAllowThreads();
8793 result = (wxLog *)new wxLog();
8794
8795 wxPyEndAllowThreads(__tstate);
8796 if (PyErr_Occurred()) SWIG_fail;
8797 }
8798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8799 return resultobj;
8800 fail:
8801 return NULL;
8802 }
8803
8804
8805 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8806 PyObject *resultobj;
8807 bool result;
8808 char *kwnames[] = {
8809 NULL
8810 };
8811
8812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 result = (bool)wxLog::IsEnabled();
8816
8817 wxPyEndAllowThreads(__tstate);
8818 if (PyErr_Occurred()) SWIG_fail;
8819 }
8820 {
8821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8822 }
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj;
8831 bool arg1 = (bool) true ;
8832 bool result;
8833 PyObject * obj0 = 0 ;
8834 char *kwnames[] = {
8835 (char *) "doIt", NULL
8836 };
8837
8838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8839 if (obj0) {
8840 {
8841 arg1 = (bool)(SWIG_As_bool(obj0));
8842 if (SWIG_arg_fail(1)) SWIG_fail;
8843 }
8844 }
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 result = (bool)wxLog::EnableLogging(arg1);
8848
8849 wxPyEndAllowThreads(__tstate);
8850 if (PyErr_Occurred()) SWIG_fail;
8851 }
8852 {
8853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8854 }
8855 return resultobj;
8856 fail:
8857 return NULL;
8858 }
8859
8860
8861 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8862 PyObject *resultobj;
8863 wxLogLevel arg1 ;
8864 wxChar *arg2 = (wxChar *) 0 ;
8865 time_t arg3 ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 PyObject * obj2 = 0 ;
8869 char *kwnames[] = {
8870 (char *) "level",(char *) "szString",(char *) "t", NULL
8871 };
8872
8873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8874 {
8875 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8876 if (SWIG_arg_fail(1)) SWIG_fail;
8877 }
8878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8879 if (SWIG_arg_fail(2)) SWIG_fail;
8880 {
8881 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8882 if (SWIG_arg_fail(3)) SWIG_fail;
8883 }
8884 {
8885 PyThreadState* __tstate = wxPyBeginAllowThreads();
8886 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8887
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 Py_INCREF(Py_None); resultobj = Py_None;
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8899 PyObject *resultobj;
8900 wxLog *arg1 = (wxLog *) 0 ;
8901 PyObject * obj0 = 0 ;
8902 char *kwnames[] = {
8903 (char *) "self", NULL
8904 };
8905
8906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8908 if (SWIG_arg_fail(1)) SWIG_fail;
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 (arg1)->Flush();
8912
8913 wxPyEndAllowThreads(__tstate);
8914 if (PyErr_Occurred()) SWIG_fail;
8915 }
8916 Py_INCREF(Py_None); resultobj = Py_None;
8917 return resultobj;
8918 fail:
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 char *kwnames[] = {
8926 NULL
8927 };
8928
8929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 wxLog::FlushActive();
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 Py_INCREF(Py_None); resultobj = Py_None;
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj;
8946 wxLog *result;
8947 char *kwnames[] = {
8948 NULL
8949 };
8950
8951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (wxLog *)wxLog::GetActiveTarget();
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8960 return resultobj;
8961 fail:
8962 return NULL;
8963 }
8964
8965
8966 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj;
8968 wxLog *arg1 = (wxLog *) 0 ;
8969 wxLog *result;
8970 PyObject * obj0 = 0 ;
8971 char *kwnames[] = {
8972 (char *) "pLogger", NULL
8973 };
8974
8975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8977 if (SWIG_arg_fail(1)) SWIG_fail;
8978 {
8979 PyThreadState* __tstate = wxPyBeginAllowThreads();
8980 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8981
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8993 PyObject *resultobj;
8994 char *kwnames[] = {
8995 NULL
8996 };
8997
8998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8999 {
9000 PyThreadState* __tstate = wxPyBeginAllowThreads();
9001 wxLog::Suspend();
9002
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 Py_INCREF(Py_None); resultobj = Py_None;
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj;
9015 char *kwnames[] = {
9016 NULL
9017 };
9018
9019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9020 {
9021 PyThreadState* __tstate = wxPyBeginAllowThreads();
9022 wxLog::Resume();
9023
9024 wxPyEndAllowThreads(__tstate);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 Py_INCREF(Py_None); resultobj = Py_None;
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9035 PyObject *resultobj;
9036 bool arg1 = (bool) true ;
9037 PyObject * obj0 = 0 ;
9038 char *kwnames[] = {
9039 (char *) "bVerbose", NULL
9040 };
9041
9042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9043 if (obj0) {
9044 {
9045 arg1 = (bool)(SWIG_As_bool(obj0));
9046 if (SWIG_arg_fail(1)) SWIG_fail;
9047 }
9048 }
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 wxLog::SetVerbose(arg1);
9052
9053 wxPyEndAllowThreads(__tstate);
9054 if (PyErr_Occurred()) SWIG_fail;
9055 }
9056 Py_INCREF(Py_None); resultobj = Py_None;
9057 return resultobj;
9058 fail:
9059 return NULL;
9060 }
9061
9062
9063 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9064 PyObject *resultobj;
9065 wxLogLevel arg1 ;
9066 PyObject * obj0 = 0 ;
9067 char *kwnames[] = {
9068 (char *) "logLevel", NULL
9069 };
9070
9071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9072 {
9073 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9074 if (SWIG_arg_fail(1)) SWIG_fail;
9075 }
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 wxLog::SetLogLevel(arg1);
9079
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 Py_INCREF(Py_None); resultobj = Py_None;
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9091 PyObject *resultobj;
9092 char *kwnames[] = {
9093 NULL
9094 };
9095
9096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 wxLog::DontCreateOnDemand();
9100
9101 wxPyEndAllowThreads(__tstate);
9102 if (PyErr_Occurred()) SWIG_fail;
9103 }
9104 Py_INCREF(Py_None); resultobj = Py_None;
9105 return resultobj;
9106 fail:
9107 return NULL;
9108 }
9109
9110
9111 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj;
9113 wxTraceMask arg1 ;
9114 PyObject * obj0 = 0 ;
9115 char *kwnames[] = {
9116 (char *) "ulMask", NULL
9117 };
9118
9119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9120 {
9121 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9122 if (SWIG_arg_fail(1)) SWIG_fail;
9123 }
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 wxLog::SetTraceMask(arg1);
9127
9128 wxPyEndAllowThreads(__tstate);
9129 if (PyErr_Occurred()) SWIG_fail;
9130 }
9131 Py_INCREF(Py_None); resultobj = Py_None;
9132 return resultobj;
9133 fail:
9134 return NULL;
9135 }
9136
9137
9138 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9139 PyObject *resultobj;
9140 wxString *arg1 = 0 ;
9141 bool temp1 = false ;
9142 PyObject * obj0 = 0 ;
9143 char *kwnames[] = {
9144 (char *) "str", NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9148 {
9149 arg1 = wxString_in_helper(obj0);
9150 if (arg1 == NULL) SWIG_fail;
9151 temp1 = true;
9152 }
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 wxLog::AddTraceMask((wxString const &)*arg1);
9156
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 Py_INCREF(Py_None); resultobj = Py_None;
9161 {
9162 if (temp1)
9163 delete arg1;
9164 }
9165 return resultobj;
9166 fail:
9167 {
9168 if (temp1)
9169 delete arg1;
9170 }
9171 return NULL;
9172 }
9173
9174
9175 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9176 PyObject *resultobj;
9177 wxString *arg1 = 0 ;
9178 bool temp1 = false ;
9179 PyObject * obj0 = 0 ;
9180 char *kwnames[] = {
9181 (char *) "str", NULL
9182 };
9183
9184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9185 {
9186 arg1 = wxString_in_helper(obj0);
9187 if (arg1 == NULL) SWIG_fail;
9188 temp1 = true;
9189 }
9190 {
9191 PyThreadState* __tstate = wxPyBeginAllowThreads();
9192 wxLog::RemoveTraceMask((wxString const &)*arg1);
9193
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 Py_INCREF(Py_None); resultobj = Py_None;
9198 {
9199 if (temp1)
9200 delete arg1;
9201 }
9202 return resultobj;
9203 fail:
9204 {
9205 if (temp1)
9206 delete arg1;
9207 }
9208 return NULL;
9209 }
9210
9211
9212 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9213 PyObject *resultobj;
9214 char *kwnames[] = {
9215 NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 wxLog::ClearTraceMasks();
9222
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 Py_INCREF(Py_None); resultobj = Py_None;
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9234 PyObject *resultobj;
9235 wxArrayString *result;
9236 char *kwnames[] = {
9237 NULL
9238 };
9239
9240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 {
9244 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9245 result = (wxArrayString *) &_result_ref;
9246 }
9247
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 {
9252 resultobj = wxArrayString2PyList_helper(*result);
9253 }
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj;
9262 wxChar *arg1 = (wxChar *) 0 ;
9263 PyObject * obj0 = 0 ;
9264 char *kwnames[] = {
9265 (char *) "ts", NULL
9266 };
9267
9268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9270 if (SWIG_arg_fail(1)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 wxLog::SetTimestamp((wxChar const *)arg1);
9274
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 Py_INCREF(Py_None); resultobj = Py_None;
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj;
9287 bool result;
9288 char *kwnames[] = {
9289 NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 result = (bool)wxLog::GetVerbose();
9296
9297 wxPyEndAllowThreads(__tstate);
9298 if (PyErr_Occurred()) SWIG_fail;
9299 }
9300 {
9301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9302 }
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9310 PyObject *resultobj;
9311 wxTraceMask result;
9312 char *kwnames[] = {
9313 NULL
9314 };
9315
9316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (wxTraceMask)wxLog::GetTraceMask();
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 {
9325 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9326 }
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj;
9335 wxChar *arg1 = (wxChar *) 0 ;
9336 bool result;
9337 PyObject * obj0 = 0 ;
9338 char *kwnames[] = {
9339 (char *) "mask", NULL
9340 };
9341
9342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9344 if (SWIG_arg_fail(1)) SWIG_fail;
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9348
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 {
9353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9354 }
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9362 PyObject *resultobj;
9363 wxLogLevel result;
9364 char *kwnames[] = {
9365 NULL
9366 };
9367
9368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 result = (wxLogLevel)wxLog::GetLogLevel();
9372
9373 wxPyEndAllowThreads(__tstate);
9374 if (PyErr_Occurred()) SWIG_fail;
9375 }
9376 {
9377 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9378 }
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9386 PyObject *resultobj;
9387 wxChar *result;
9388 char *kwnames[] = {
9389 NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 result = (wxChar *)wxLog::GetTimestamp();
9396
9397 wxPyEndAllowThreads(__tstate);
9398 if (PyErr_Occurred()) SWIG_fail;
9399 }
9400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9401 return resultobj;
9402 fail:
9403 return NULL;
9404 }
9405
9406
9407 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9408 PyObject *resultobj;
9409 wxString result;
9410 char *kwnames[] = {
9411 NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = Log_TimeStamp();
9418
9419 wxPyEndAllowThreads(__tstate);
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 {
9423 #if wxUSE_UNICODE
9424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9425 #else
9426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9427 #endif
9428 }
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9436 PyObject *resultobj;
9437 wxLog *arg1 = (wxLog *) 0 ;
9438 PyObject * obj0 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "self", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9445 if (SWIG_arg_fail(1)) SWIG_fail;
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 wxLog_Destroy(arg1);
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 Py_INCREF(Py_None); resultobj = Py_None;
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9461 PyObject *obj;
9462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9463 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9464 Py_INCREF(obj);
9465 return Py_BuildValue((char *)"");
9466 }
9467 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9468 PyObject *resultobj;
9469 wxLogStderr *result;
9470 char *kwnames[] = {
9471 NULL
9472 };
9473
9474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (wxLogStderr *)new wxLogStderr();
9478
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9490 PyObject *obj;
9491 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9492 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9493 Py_INCREF(obj);
9494 return Py_BuildValue((char *)"");
9495 }
9496 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9497 PyObject *resultobj;
9498 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9499 wxLogTextCtrl *result;
9500 PyObject * obj0 = 0 ;
9501 char *kwnames[] = {
9502 (char *) "pTextCtrl", NULL
9503 };
9504
9505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9507 if (SWIG_arg_fail(1)) SWIG_fail;
9508 {
9509 PyThreadState* __tstate = wxPyBeginAllowThreads();
9510 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9511
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9523 PyObject *obj;
9524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9525 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9526 Py_INCREF(obj);
9527 return Py_BuildValue((char *)"");
9528 }
9529 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj;
9531 wxLogGui *result;
9532 char *kwnames[] = {
9533 NULL
9534 };
9535
9536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9537 {
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (wxLogGui *)new wxLogGui();
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9545 return resultobj;
9546 fail:
9547 return NULL;
9548 }
9549
9550
9551 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9552 PyObject *obj;
9553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9554 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9555 Py_INCREF(obj);
9556 return Py_BuildValue((char *)"");
9557 }
9558 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9559 PyObject *resultobj;
9560 wxFrame *arg1 = (wxFrame *) 0 ;
9561 wxString *arg2 = 0 ;
9562 bool arg3 = (bool) true ;
9563 bool arg4 = (bool) true ;
9564 wxLogWindow *result;
9565 bool temp2 = false ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 PyObject * obj2 = 0 ;
9569 PyObject * obj3 = 0 ;
9570 char *kwnames[] = {
9571 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9572 };
9573
9574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9576 if (SWIG_arg_fail(1)) SWIG_fail;
9577 {
9578 arg2 = wxString_in_helper(obj1);
9579 if (arg2 == NULL) SWIG_fail;
9580 temp2 = true;
9581 }
9582 if (obj2) {
9583 {
9584 arg3 = (bool)(SWIG_As_bool(obj2));
9585 if (SWIG_arg_fail(3)) SWIG_fail;
9586 }
9587 }
9588 if (obj3) {
9589 {
9590 arg4 = (bool)(SWIG_As_bool(obj3));
9591 if (SWIG_arg_fail(4)) SWIG_fail;
9592 }
9593 }
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9597
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9602 {
9603 if (temp2)
9604 delete arg2;
9605 }
9606 return resultobj;
9607 fail:
9608 {
9609 if (temp2)
9610 delete arg2;
9611 }
9612 return NULL;
9613 }
9614
9615
9616 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9617 PyObject *resultobj;
9618 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9619 bool arg2 = (bool) true ;
9620 PyObject * obj0 = 0 ;
9621 PyObject * obj1 = 0 ;
9622 char *kwnames[] = {
9623 (char *) "self",(char *) "bShow", NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9628 if (SWIG_arg_fail(1)) SWIG_fail;
9629 if (obj1) {
9630 {
9631 arg2 = (bool)(SWIG_As_bool(obj1));
9632 if (SWIG_arg_fail(2)) SWIG_fail;
9633 }
9634 }
9635 {
9636 PyThreadState* __tstate = wxPyBeginAllowThreads();
9637 (arg1)->Show(arg2);
9638
9639 wxPyEndAllowThreads(__tstate);
9640 if (PyErr_Occurred()) SWIG_fail;
9641 }
9642 Py_INCREF(Py_None); resultobj = Py_None;
9643 return resultobj;
9644 fail:
9645 return NULL;
9646 }
9647
9648
9649 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9650 PyObject *resultobj;
9651 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9652 wxFrame *result;
9653 PyObject * obj0 = 0 ;
9654 char *kwnames[] = {
9655 (char *) "self", NULL
9656 };
9657
9658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9660 if (SWIG_arg_fail(1)) SWIG_fail;
9661 {
9662 PyThreadState* __tstate = wxPyBeginAllowThreads();
9663 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9664
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 {
9669 resultobj = wxPyMake_wxObject(result, 0);
9670 }
9671 return resultobj;
9672 fail:
9673 return NULL;
9674 }
9675
9676
9677 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9678 PyObject *resultobj;
9679 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9680 wxLog *result;
9681 PyObject * obj0 = 0 ;
9682 char *kwnames[] = {
9683 (char *) "self", NULL
9684 };
9685
9686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9688 if (SWIG_arg_fail(1)) SWIG_fail;
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9692
9693 wxPyEndAllowThreads(__tstate);
9694 if (PyErr_Occurred()) SWIG_fail;
9695 }
9696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9704 PyObject *resultobj;
9705 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9706 bool result;
9707 PyObject * obj0 = 0 ;
9708 char *kwnames[] = {
9709 (char *) "self", NULL
9710 };
9711
9712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9714 if (SWIG_arg_fail(1)) SWIG_fail;
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 {
9723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9724 }
9725 return resultobj;
9726 fail:
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj;
9733 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9734 bool arg2 ;
9735 PyObject * obj0 = 0 ;
9736 PyObject * obj1 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "self",(char *) "bDoPass", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9743 if (SWIG_arg_fail(1)) SWIG_fail;
9744 {
9745 arg2 = (bool)(SWIG_As_bool(obj1));
9746 if (SWIG_arg_fail(2)) SWIG_fail;
9747 }
9748 {
9749 PyThreadState* __tstate = wxPyBeginAllowThreads();
9750 (arg1)->PassMessages(arg2);
9751
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 Py_INCREF(Py_None); resultobj = Py_None;
9756 return resultobj;
9757 fail:
9758 return NULL;
9759 }
9760
9761
9762 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9763 PyObject *obj;
9764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9765 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9766 Py_INCREF(obj);
9767 return Py_BuildValue((char *)"");
9768 }
9769 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9770 PyObject *resultobj;
9771 wxLog *arg1 = (wxLog *) 0 ;
9772 wxLogChain *result;
9773 PyObject * obj0 = 0 ;
9774 char *kwnames[] = {
9775 (char *) "logger", NULL
9776 };
9777
9778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9780 if (SWIG_arg_fail(1)) SWIG_fail;
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 result = (wxLogChain *)new wxLogChain(arg1);
9784
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9796 PyObject *resultobj;
9797 wxLogChain *arg1 = (wxLogChain *) 0 ;
9798 wxLog *arg2 = (wxLog *) 0 ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9801 char *kwnames[] = {
9802 (char *) "self",(char *) "logger", NULL
9803 };
9804
9805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(1)) SWIG_fail;
9808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9809 if (SWIG_arg_fail(2)) SWIG_fail;
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 (arg1)->SetLog(arg2);
9813
9814 wxPyEndAllowThreads(__tstate);
9815 if (PyErr_Occurred()) SWIG_fail;
9816 }
9817 Py_INCREF(Py_None); resultobj = Py_None;
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxLogChain *arg1 = (wxLogChain *) 0 ;
9827 bool arg2 ;
9828 PyObject * obj0 = 0 ;
9829 PyObject * obj1 = 0 ;
9830 char *kwnames[] = {
9831 (char *) "self",(char *) "bDoPass", NULL
9832 };
9833
9834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9836 if (SWIG_arg_fail(1)) SWIG_fail;
9837 {
9838 arg2 = (bool)(SWIG_As_bool(obj1));
9839 if (SWIG_arg_fail(2)) SWIG_fail;
9840 }
9841 {
9842 PyThreadState* __tstate = wxPyBeginAllowThreads();
9843 (arg1)->PassMessages(arg2);
9844
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 Py_INCREF(Py_None); resultobj = Py_None;
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj;
9857 wxLogChain *arg1 = (wxLogChain *) 0 ;
9858 bool result;
9859 PyObject * obj0 = 0 ;
9860 char *kwnames[] = {
9861 (char *) "self", NULL
9862 };
9863
9864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9866 if (SWIG_arg_fail(1)) SWIG_fail;
9867 {
9868 PyThreadState* __tstate = wxPyBeginAllowThreads();
9869 result = (bool)(arg1)->IsPassingMessages();
9870
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9876 }
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9884 PyObject *resultobj;
9885 wxLogChain *arg1 = (wxLogChain *) 0 ;
9886 wxLog *result;
9887 PyObject * obj0 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "self", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 result = (wxLog *)(arg1)->GetOldLog();
9898
9899 wxPyEndAllowThreads(__tstate);
9900 if (PyErr_Occurred()) SWIG_fail;
9901 }
9902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9903 return resultobj;
9904 fail:
9905 return NULL;
9906 }
9907
9908
9909 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9910 PyObject *obj;
9911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9912 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9913 Py_INCREF(obj);
9914 return Py_BuildValue((char *)"");
9915 }
9916 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9917 PyObject *resultobj;
9918 unsigned long result;
9919 char *kwnames[] = {
9920 NULL
9921 };
9922
9923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (unsigned long)wxSysErrorCode();
9927
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 {
9932 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9933 }
9934 return resultobj;
9935 fail:
9936 return NULL;
9937 }
9938
9939
9940 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9941 PyObject *resultobj;
9942 unsigned long arg1 = (unsigned long) 0 ;
9943 wxString result;
9944 PyObject * obj0 = 0 ;
9945 char *kwnames[] = {
9946 (char *) "nErrCode", NULL
9947 };
9948
9949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9950 if (obj0) {
9951 {
9952 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9953 if (SWIG_arg_fail(1)) SWIG_fail;
9954 }
9955 }
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 result = wxSysErrorMsg(arg1);
9959
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 {
9964 #if wxUSE_UNICODE
9965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9966 #else
9967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9968 #endif
9969 }
9970 return resultobj;
9971 fail:
9972 return NULL;
9973 }
9974
9975
9976 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9977 PyObject *resultobj;
9978 wxString *arg1 = 0 ;
9979 bool temp1 = false ;
9980 PyObject * obj0 = 0 ;
9981 char *kwnames[] = {
9982 (char *) "msg", NULL
9983 };
9984
9985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9986 {
9987 arg1 = wxString_in_helper(obj0);
9988 if (arg1 == NULL) SWIG_fail;
9989 temp1 = true;
9990 }
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 wxPyLogFatalError((wxString const &)*arg1);
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 Py_INCREF(Py_None); resultobj = Py_None;
9999 {
10000 if (temp1)
10001 delete arg1;
10002 }
10003 return resultobj;
10004 fail:
10005 {
10006 if (temp1)
10007 delete arg1;
10008 }
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxString *arg1 = 0 ;
10016 bool temp1 = false ;
10017 PyObject * obj0 = 0 ;
10018 char *kwnames[] = {
10019 (char *) "msg", NULL
10020 };
10021
10022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10023 {
10024 arg1 = wxString_in_helper(obj0);
10025 if (arg1 == NULL) SWIG_fail;
10026 temp1 = true;
10027 }
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 wxPyLogError((wxString const &)*arg1);
10031
10032 wxPyEndAllowThreads(__tstate);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 Py_INCREF(Py_None); resultobj = Py_None;
10036 {
10037 if (temp1)
10038 delete arg1;
10039 }
10040 return resultobj;
10041 fail:
10042 {
10043 if (temp1)
10044 delete arg1;
10045 }
10046 return NULL;
10047 }
10048
10049
10050 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10051 PyObject *resultobj;
10052 wxString *arg1 = 0 ;
10053 bool temp1 = false ;
10054 PyObject * obj0 = 0 ;
10055 char *kwnames[] = {
10056 (char *) "msg", NULL
10057 };
10058
10059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10060 {
10061 arg1 = wxString_in_helper(obj0);
10062 if (arg1 == NULL) SWIG_fail;
10063 temp1 = true;
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 wxPyLogWarning((wxString const &)*arg1);
10068
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 Py_INCREF(Py_None); resultobj = Py_None;
10073 {
10074 if (temp1)
10075 delete arg1;
10076 }
10077 return resultobj;
10078 fail:
10079 {
10080 if (temp1)
10081 delete arg1;
10082 }
10083 return NULL;
10084 }
10085
10086
10087 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj;
10089 wxString *arg1 = 0 ;
10090 bool temp1 = false ;
10091 PyObject * obj0 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "msg", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10097 {
10098 arg1 = wxString_in_helper(obj0);
10099 if (arg1 == NULL) SWIG_fail;
10100 temp1 = true;
10101 }
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 wxPyLogMessage((wxString const &)*arg1);
10105
10106 wxPyEndAllowThreads(__tstate);
10107 if (PyErr_Occurred()) SWIG_fail;
10108 }
10109 Py_INCREF(Py_None); resultobj = Py_None;
10110 {
10111 if (temp1)
10112 delete arg1;
10113 }
10114 return resultobj;
10115 fail:
10116 {
10117 if (temp1)
10118 delete arg1;
10119 }
10120 return NULL;
10121 }
10122
10123
10124 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj;
10126 wxString *arg1 = 0 ;
10127 bool temp1 = false ;
10128 PyObject * obj0 = 0 ;
10129 char *kwnames[] = {
10130 (char *) "msg", NULL
10131 };
10132
10133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10134 {
10135 arg1 = wxString_in_helper(obj0);
10136 if (arg1 == NULL) SWIG_fail;
10137 temp1 = true;
10138 }
10139 {
10140 PyThreadState* __tstate = wxPyBeginAllowThreads();
10141 wxPyLogInfo((wxString const &)*arg1);
10142
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 Py_INCREF(Py_None); resultobj = Py_None;
10147 {
10148 if (temp1)
10149 delete arg1;
10150 }
10151 return resultobj;
10152 fail:
10153 {
10154 if (temp1)
10155 delete arg1;
10156 }
10157 return NULL;
10158 }
10159
10160
10161 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj;
10163 wxString *arg1 = 0 ;
10164 bool temp1 = false ;
10165 PyObject * obj0 = 0 ;
10166 char *kwnames[] = {
10167 (char *) "msg", NULL
10168 };
10169
10170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10171 {
10172 arg1 = wxString_in_helper(obj0);
10173 if (arg1 == NULL) SWIG_fail;
10174 temp1 = true;
10175 }
10176 {
10177 PyThreadState* __tstate = wxPyBeginAllowThreads();
10178 wxPyLogDebug((wxString const &)*arg1);
10179
10180 wxPyEndAllowThreads(__tstate);
10181 if (PyErr_Occurred()) SWIG_fail;
10182 }
10183 Py_INCREF(Py_None); resultobj = Py_None;
10184 {
10185 if (temp1)
10186 delete arg1;
10187 }
10188 return resultobj;
10189 fail:
10190 {
10191 if (temp1)
10192 delete arg1;
10193 }
10194 return NULL;
10195 }
10196
10197
10198 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj;
10200 wxString *arg1 = 0 ;
10201 bool temp1 = false ;
10202 PyObject * obj0 = 0 ;
10203 char *kwnames[] = {
10204 (char *) "msg", NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10208 {
10209 arg1 = wxString_in_helper(obj0);
10210 if (arg1 == NULL) SWIG_fail;
10211 temp1 = true;
10212 }
10213 {
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 wxPyLogVerbose((wxString const &)*arg1);
10216
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 Py_INCREF(Py_None); resultobj = Py_None;
10221 {
10222 if (temp1)
10223 delete arg1;
10224 }
10225 return resultobj;
10226 fail:
10227 {
10228 if (temp1)
10229 delete arg1;
10230 }
10231 return NULL;
10232 }
10233
10234
10235 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj;
10237 wxString *arg1 = 0 ;
10238 bool temp1 = false ;
10239 PyObject * obj0 = 0 ;
10240 char *kwnames[] = {
10241 (char *) "msg", NULL
10242 };
10243
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10245 {
10246 arg1 = wxString_in_helper(obj0);
10247 if (arg1 == NULL) SWIG_fail;
10248 temp1 = true;
10249 }
10250 {
10251 PyThreadState* __tstate = wxPyBeginAllowThreads();
10252 wxPyLogStatus((wxString const &)*arg1);
10253
10254 wxPyEndAllowThreads(__tstate);
10255 if (PyErr_Occurred()) SWIG_fail;
10256 }
10257 Py_INCREF(Py_None); resultobj = Py_None;
10258 {
10259 if (temp1)
10260 delete arg1;
10261 }
10262 return resultobj;
10263 fail:
10264 {
10265 if (temp1)
10266 delete arg1;
10267 }
10268 return NULL;
10269 }
10270
10271
10272 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10273 PyObject *resultobj;
10274 wxFrame *arg1 = (wxFrame *) 0 ;
10275 wxString *arg2 = 0 ;
10276 bool temp2 = false ;
10277 PyObject * obj0 = 0 ;
10278 PyObject * obj1 = 0 ;
10279 char *kwnames[] = {
10280 (char *) "pFrame",(char *) "msg", NULL
10281 };
10282
10283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10285 if (SWIG_arg_fail(1)) SWIG_fail;
10286 {
10287 arg2 = wxString_in_helper(obj1);
10288 if (arg2 == NULL) SWIG_fail;
10289 temp2 = true;
10290 }
10291 {
10292 PyThreadState* __tstate = wxPyBeginAllowThreads();
10293 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10294
10295 wxPyEndAllowThreads(__tstate);
10296 if (PyErr_Occurred()) SWIG_fail;
10297 }
10298 Py_INCREF(Py_None); resultobj = Py_None;
10299 {
10300 if (temp2)
10301 delete arg2;
10302 }
10303 return resultobj;
10304 fail:
10305 {
10306 if (temp2)
10307 delete arg2;
10308 }
10309 return NULL;
10310 }
10311
10312
10313 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj;
10315 wxString *arg1 = 0 ;
10316 bool temp1 = false ;
10317 PyObject * obj0 = 0 ;
10318 char *kwnames[] = {
10319 (char *) "msg", NULL
10320 };
10321
10322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10323 {
10324 arg1 = wxString_in_helper(obj0);
10325 if (arg1 == NULL) SWIG_fail;
10326 temp1 = true;
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 wxPyLogSysError((wxString const &)*arg1);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 Py_INCREF(Py_None); resultobj = Py_None;
10336 {
10337 if (temp1)
10338 delete arg1;
10339 }
10340 return resultobj;
10341 fail:
10342 {
10343 if (temp1)
10344 delete arg1;
10345 }
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 unsigned long arg1 ;
10353 wxString *arg2 = 0 ;
10354 bool temp2 = false ;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "level",(char *) "msg", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10362 {
10363 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10364 if (SWIG_arg_fail(1)) SWIG_fail;
10365 }
10366 {
10367 arg2 = wxString_in_helper(obj1);
10368 if (arg2 == NULL) SWIG_fail;
10369 temp2 = true;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 Py_INCREF(Py_None); resultobj = Py_None;
10379 {
10380 if (temp2)
10381 delete arg2;
10382 }
10383 return resultobj;
10384 fail:
10385 {
10386 if (temp2)
10387 delete arg2;
10388 }
10389 return NULL;
10390 }
10391
10392
10393 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10394 PyObject *resultobj;
10395 unsigned long arg1 ;
10396 wxString *arg2 = 0 ;
10397 bool temp2 = false ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400
10401 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10402 {
10403 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10404 if (SWIG_arg_fail(1)) SWIG_fail;
10405 }
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 wxPyLogTrace(arg1,(wxString const &)*arg2);
10414
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 Py_INCREF(Py_None); resultobj = Py_None;
10419 {
10420 if (temp2)
10421 delete arg2;
10422 }
10423 return resultobj;
10424 fail:
10425 {
10426 if (temp2)
10427 delete arg2;
10428 }
10429 return NULL;
10430 }
10431
10432
10433 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10434 PyObject *resultobj;
10435 wxString *arg1 = 0 ;
10436 wxString *arg2 = 0 ;
10437 bool temp1 = false ;
10438 bool temp2 = false ;
10439 PyObject * obj0 = 0 ;
10440 PyObject * obj1 = 0 ;
10441
10442 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10443 {
10444 arg1 = wxString_in_helper(obj0);
10445 if (arg1 == NULL) SWIG_fail;
10446 temp1 = true;
10447 }
10448 {
10449 arg2 = wxString_in_helper(obj1);
10450 if (arg2 == NULL) SWIG_fail;
10451 temp2 = true;
10452 }
10453 {
10454 PyThreadState* __tstate = wxPyBeginAllowThreads();
10455 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10456
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 Py_INCREF(Py_None); resultobj = Py_None;
10461 {
10462 if (temp1)
10463 delete arg1;
10464 }
10465 {
10466 if (temp2)
10467 delete arg2;
10468 }
10469 return resultobj;
10470 fail:
10471 {
10472 if (temp1)
10473 delete arg1;
10474 }
10475 {
10476 if (temp2)
10477 delete arg2;
10478 }
10479 return NULL;
10480 }
10481
10482
10483 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10484 int argc;
10485 PyObject *argv[3];
10486 int ii;
10487
10488 argc = PyObject_Length(args);
10489 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10490 argv[ii] = PyTuple_GetItem(args,ii);
10491 }
10492 if (argc == 2) {
10493 int _v;
10494 {
10495 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10496 }
10497 if (_v) {
10498 {
10499 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10500 }
10501 if (_v) {
10502 return _wrap_LogTrace__SWIG_1(self,args);
10503 }
10504 }
10505 }
10506 if (argc == 2) {
10507 int _v;
10508 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10509 if (_v) {
10510 {
10511 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10512 }
10513 if (_v) {
10514 return _wrap_LogTrace__SWIG_0(self,args);
10515 }
10516 }
10517 }
10518
10519 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10520 return NULL;
10521 }
10522
10523
10524 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10525 PyObject *resultobj;
10526 wxString *arg1 = 0 ;
10527 wxString *arg2 = 0 ;
10528 bool temp1 = false ;
10529 bool temp2 = false ;
10530 PyObject * obj0 = 0 ;
10531 PyObject * obj1 = 0 ;
10532 char *kwnames[] = {
10533 (char *) "title",(char *) "text", NULL
10534 };
10535
10536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10537 {
10538 arg1 = wxString_in_helper(obj0);
10539 if (arg1 == NULL) SWIG_fail;
10540 temp1 = true;
10541 }
10542 {
10543 arg2 = wxString_in_helper(obj1);
10544 if (arg2 == NULL) SWIG_fail;
10545 temp2 = true;
10546 }
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 Py_INCREF(Py_None); resultobj = Py_None;
10555 {
10556 if (temp1)
10557 delete arg1;
10558 }
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return resultobj;
10564 fail:
10565 {
10566 if (temp1)
10567 delete arg1;
10568 }
10569 {
10570 if (temp2)
10571 delete arg2;
10572 }
10573 return NULL;
10574 }
10575
10576
10577 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10578 PyObject *resultobj;
10579 wxLogNull *result;
10580 char *kwnames[] = {
10581 NULL
10582 };
10583
10584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10585 {
10586 PyThreadState* __tstate = wxPyBeginAllowThreads();
10587 result = (wxLogNull *)new wxLogNull();
10588
10589 wxPyEndAllowThreads(__tstate);
10590 if (PyErr_Occurred()) SWIG_fail;
10591 }
10592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj;
10601 wxLogNull *arg1 = (wxLogNull *) 0 ;
10602 PyObject * obj0 = 0 ;
10603 char *kwnames[] = {
10604 (char *) "self", NULL
10605 };
10606
10607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10609 if (SWIG_arg_fail(1)) SWIG_fail;
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 delete arg1;
10613
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 Py_INCREF(Py_None); resultobj = Py_None;
10618 return resultobj;
10619 fail:
10620 return NULL;
10621 }
10622
10623
10624 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10625 PyObject *obj;
10626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10627 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10628 Py_INCREF(obj);
10629 return Py_BuildValue((char *)"");
10630 }
10631 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj;
10633 wxPyLog *result;
10634 char *kwnames[] = {
10635 NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (wxPyLog *)new wxPyLog();
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10647 return resultobj;
10648 fail:
10649 return NULL;
10650 }
10651
10652
10653 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10654 PyObject *resultobj;
10655 wxPyLog *arg1 = (wxPyLog *) 0 ;
10656 PyObject *arg2 = (PyObject *) 0 ;
10657 PyObject *arg3 = (PyObject *) 0 ;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10661 char *kwnames[] = {
10662 (char *) "self",(char *) "self",(char *) "_class", NULL
10663 };
10664
10665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10667 if (SWIG_arg_fail(1)) SWIG_fail;
10668 arg2 = obj1;
10669 arg3 = obj2;
10670 {
10671 PyThreadState* __tstate = wxPyBeginAllowThreads();
10672 (arg1)->_setCallbackInfo(arg2,arg3);
10673
10674 wxPyEndAllowThreads(__tstate);
10675 if (PyErr_Occurred()) SWIG_fail;
10676 }
10677 Py_INCREF(Py_None); resultobj = Py_None;
10678 return resultobj;
10679 fail:
10680 return NULL;
10681 }
10682
10683
10684 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10685 PyObject *obj;
10686 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10687 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10688 Py_INCREF(obj);
10689 return Py_BuildValue((char *)"");
10690 }
10691 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj;
10693 int arg1 ;
10694 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10695 int arg3 = (int) wxKILL_NOCHILDREN ;
10696 wxKillError result;
10697 PyObject * obj0 = 0 ;
10698 PyObject * obj1 = 0 ;
10699 PyObject * obj2 = 0 ;
10700 char *kwnames[] = {
10701 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10702 };
10703
10704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10705 {
10706 arg1 = (int)(SWIG_As_int(obj0));
10707 if (SWIG_arg_fail(1)) SWIG_fail;
10708 }
10709 if (obj1) {
10710 {
10711 arg2 = (wxSignal)(SWIG_As_int(obj1));
10712 if (SWIG_arg_fail(2)) SWIG_fail;
10713 }
10714 }
10715 if (obj2) {
10716 {
10717 arg3 = (int)(SWIG_As_int(obj2));
10718 if (SWIG_arg_fail(3)) SWIG_fail;
10719 }
10720 }
10721 {
10722 PyThreadState* __tstate = wxPyBeginAllowThreads();
10723 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10724
10725 wxPyEndAllowThreads(__tstate);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 resultobj = SWIG_From_int((result));
10729 return resultobj;
10730 fail:
10731 return NULL;
10732 }
10733
10734
10735 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj;
10737 int arg1 ;
10738 bool result;
10739 PyObject * obj0 = 0 ;
10740 char *kwnames[] = {
10741 (char *) "pid", NULL
10742 };
10743
10744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10745 {
10746 arg1 = (int)(SWIG_As_int(obj0));
10747 if (SWIG_arg_fail(1)) SWIG_fail;
10748 }
10749 {
10750 PyThreadState* __tstate = wxPyBeginAllowThreads();
10751 result = (bool)wxPyProcess::Exists(arg1);
10752
10753 wxPyEndAllowThreads(__tstate);
10754 if (PyErr_Occurred()) SWIG_fail;
10755 }
10756 {
10757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10758 }
10759 return resultobj;
10760 fail:
10761 return NULL;
10762 }
10763
10764
10765 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj;
10767 wxString *arg1 = 0 ;
10768 int arg2 = (int) wxEXEC_ASYNC ;
10769 wxPyProcess *result;
10770 bool temp1 = false ;
10771 PyObject * obj0 = 0 ;
10772 PyObject * obj1 = 0 ;
10773 char *kwnames[] = {
10774 (char *) "cmd",(char *) "flags", NULL
10775 };
10776
10777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10778 {
10779 arg1 = wxString_in_helper(obj0);
10780 if (arg1 == NULL) SWIG_fail;
10781 temp1 = true;
10782 }
10783 if (obj1) {
10784 {
10785 arg2 = (int)(SWIG_As_int(obj1));
10786 if (SWIG_arg_fail(2)) SWIG_fail;
10787 }
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10792
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10797 {
10798 if (temp1)
10799 delete arg1;
10800 }
10801 return resultobj;
10802 fail:
10803 {
10804 if (temp1)
10805 delete arg1;
10806 }
10807 return NULL;
10808 }
10809
10810
10811 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10812 PyObject *resultobj;
10813 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10814 int arg2 = (int) -1 ;
10815 wxPyProcess *result;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "parent",(char *) "id", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10823 if (obj0) {
10824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10825 if (SWIG_arg_fail(1)) SWIG_fail;
10826 }
10827 if (obj1) {
10828 {
10829 arg2 = (int)(SWIG_As_int(obj1));
10830 if (SWIG_arg_fail(2)) SWIG_fail;
10831 }
10832 }
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10836
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj;
10849 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10850 PyObject *arg2 = (PyObject *) 0 ;
10851 PyObject *arg3 = (PyObject *) 0 ;
10852 PyObject * obj0 = 0 ;
10853 PyObject * obj1 = 0 ;
10854 PyObject * obj2 = 0 ;
10855 char *kwnames[] = {
10856 (char *) "self",(char *) "self",(char *) "_class", NULL
10857 };
10858
10859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10861 if (SWIG_arg_fail(1)) SWIG_fail;
10862 arg2 = obj1;
10863 arg3 = obj2;
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 (arg1)->_setCallbackInfo(arg2,arg3);
10867
10868 wxPyEndAllowThreads(__tstate);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 Py_INCREF(Py_None); resultobj = Py_None;
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10879 PyObject *resultobj;
10880 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 PyObject * obj2 = 0 ;
10886 char *kwnames[] = {
10887 (char *) "self",(char *) "pid",(char *) "status", NULL
10888 };
10889
10890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10892 if (SWIG_arg_fail(1)) SWIG_fail;
10893 {
10894 arg2 = (int)(SWIG_As_int(obj1));
10895 if (SWIG_arg_fail(2)) SWIG_fail;
10896 }
10897 {
10898 arg3 = (int)(SWIG_As_int(obj2));
10899 if (SWIG_arg_fail(3)) SWIG_fail;
10900 }
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 (arg1)->base_OnTerminate(arg2,arg3);
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 Py_INCREF(Py_None); resultobj = Py_None;
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj;
10917 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10918 PyObject * obj0 = 0 ;
10919 char *kwnames[] = {
10920 (char *) "self", NULL
10921 };
10922
10923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10925 if (SWIG_arg_fail(1)) SWIG_fail;
10926 {
10927 PyThreadState* __tstate = wxPyBeginAllowThreads();
10928 (arg1)->Redirect();
10929
10930 wxPyEndAllowThreads(__tstate);
10931 if (PyErr_Occurred()) SWIG_fail;
10932 }
10933 Py_INCREF(Py_None); resultobj = Py_None;
10934 return resultobj;
10935 fail:
10936 return NULL;
10937 }
10938
10939
10940 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10941 PyObject *resultobj;
10942 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10943 bool result;
10944 PyObject * obj0 = 0 ;
10945 char *kwnames[] = {
10946 (char *) "self", NULL
10947 };
10948
10949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10951 if (SWIG_arg_fail(1)) SWIG_fail;
10952 {
10953 PyThreadState* __tstate = wxPyBeginAllowThreads();
10954 result = (bool)(arg1)->IsRedirected();
10955
10956 wxPyEndAllowThreads(__tstate);
10957 if (PyErr_Occurred()) SWIG_fail;
10958 }
10959 {
10960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10961 }
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10969 PyObject *resultobj;
10970 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10971 PyObject * obj0 = 0 ;
10972 char *kwnames[] = {
10973 (char *) "self", NULL
10974 };
10975
10976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10978 if (SWIG_arg_fail(1)) SWIG_fail;
10979 {
10980 PyThreadState* __tstate = wxPyBeginAllowThreads();
10981 (arg1)->Detach();
10982
10983 wxPyEndAllowThreads(__tstate);
10984 if (PyErr_Occurred()) SWIG_fail;
10985 }
10986 Py_INCREF(Py_None); resultobj = Py_None;
10987 return resultobj;
10988 fail:
10989 return NULL;
10990 }
10991
10992
10993 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10994 PyObject *resultobj;
10995 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10996 wxInputStream *result;
10997 PyObject * obj0 = 0 ;
10998 char *kwnames[] = {
10999 (char *) "self", NULL
11000 };
11001
11002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11004 if (SWIG_arg_fail(1)) SWIG_fail;
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = (wxInputStream *)(arg1)->GetInputStream();
11008
11009 wxPyEndAllowThreads(__tstate);
11010 if (PyErr_Occurred()) SWIG_fail;
11011 }
11012 {
11013 wxPyInputStream * _ptr = NULL;
11014
11015 if (result) {
11016 _ptr = new wxPyInputStream(result);
11017 }
11018 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11019 }
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj;
11028 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11029 wxInputStream *result;
11030 PyObject * obj0 = 0 ;
11031 char *kwnames[] = {
11032 (char *) "self", NULL
11033 };
11034
11035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11037 if (SWIG_arg_fail(1)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (wxInputStream *)(arg1)->GetErrorStream();
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 wxPyInputStream * _ptr = NULL;
11047
11048 if (result) {
11049 _ptr = new wxPyInputStream(result);
11050 }
11051 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11052 }
11053 return resultobj;
11054 fail:
11055 return NULL;
11056 }
11057
11058
11059 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj;
11061 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11062 wxOutputStream *result;
11063 PyObject * obj0 = 0 ;
11064 char *kwnames[] = {
11065 (char *) "self", NULL
11066 };
11067
11068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11070 if (SWIG_arg_fail(1)) SWIG_fail;
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 result = (wxOutputStream *)(arg1)->GetOutputStream();
11074
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11086 PyObject *resultobj;
11087 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11088 PyObject * obj0 = 0 ;
11089 char *kwnames[] = {
11090 (char *) "self", NULL
11091 };
11092
11093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11095 if (SWIG_arg_fail(1)) SWIG_fail;
11096 {
11097 PyThreadState* __tstate = wxPyBeginAllowThreads();
11098 (arg1)->CloseOutput();
11099
11100 wxPyEndAllowThreads(__tstate);
11101 if (PyErr_Occurred()) SWIG_fail;
11102 }
11103 Py_INCREF(Py_None); resultobj = Py_None;
11104 return resultobj;
11105 fail:
11106 return NULL;
11107 }
11108
11109
11110 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj;
11112 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11113 bool result;
11114 PyObject * obj0 = 0 ;
11115 char *kwnames[] = {
11116 (char *) "self", NULL
11117 };
11118
11119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11121 if (SWIG_arg_fail(1)) SWIG_fail;
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11125
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 {
11130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj;
11140 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11141 bool result;
11142 PyObject * obj0 = 0 ;
11143 char *kwnames[] = {
11144 (char *) "self", NULL
11145 };
11146
11147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11149 if (SWIG_arg_fail(1)) SWIG_fail;
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 {
11158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11159 }
11160 return resultobj;
11161 fail:
11162 return NULL;
11163 }
11164
11165
11166 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj;
11168 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11169 bool result;
11170 PyObject * obj0 = 0 ;
11171 char *kwnames[] = {
11172 (char *) "self", NULL
11173 };
11174
11175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11177 if (SWIG_arg_fail(1)) SWIG_fail;
11178 {
11179 PyThreadState* __tstate = wxPyBeginAllowThreads();
11180 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11181
11182 wxPyEndAllowThreads(__tstate);
11183 if (PyErr_Occurred()) SWIG_fail;
11184 }
11185 {
11186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11187 }
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11195 PyObject *obj;
11196 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11197 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11198 Py_INCREF(obj);
11199 return Py_BuildValue((char *)"");
11200 }
11201 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj;
11203 int arg1 = (int) 0 ;
11204 int arg2 = (int) 0 ;
11205 int arg3 = (int) 0 ;
11206 wxProcessEvent *result;
11207 PyObject * obj0 = 0 ;
11208 PyObject * obj1 = 0 ;
11209 PyObject * obj2 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11215 if (obj0) {
11216 {
11217 arg1 = (int)(SWIG_As_int(obj0));
11218 if (SWIG_arg_fail(1)) SWIG_fail;
11219 }
11220 }
11221 if (obj1) {
11222 {
11223 arg2 = (int)(SWIG_As_int(obj1));
11224 if (SWIG_arg_fail(2)) SWIG_fail;
11225 }
11226 }
11227 if (obj2) {
11228 {
11229 arg3 = (int)(SWIG_As_int(obj2));
11230 if (SWIG_arg_fail(3)) SWIG_fail;
11231 }
11232 }
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11236
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11241 return resultobj;
11242 fail:
11243 return NULL;
11244 }
11245
11246
11247 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11248 PyObject *resultobj;
11249 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11250 int result;
11251 PyObject * obj0 = 0 ;
11252 char *kwnames[] = {
11253 (char *) "self", NULL
11254 };
11255
11256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11258 if (SWIG_arg_fail(1)) SWIG_fail;
11259 {
11260 PyThreadState* __tstate = wxPyBeginAllowThreads();
11261 result = (int)(arg1)->GetPid();
11262
11263 wxPyEndAllowThreads(__tstate);
11264 if (PyErr_Occurred()) SWIG_fail;
11265 }
11266 {
11267 resultobj = SWIG_From_int((int)(result));
11268 }
11269 return resultobj;
11270 fail:
11271 return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj;
11277 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11278 int result;
11279 PyObject * obj0 = 0 ;
11280 char *kwnames[] = {
11281 (char *) "self", NULL
11282 };
11283
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (int)(arg1)->GetExitCode();
11290
11291 wxPyEndAllowThreads(__tstate);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 {
11295 resultobj = SWIG_From_int((int)(result));
11296 }
11297 return resultobj;
11298 fail:
11299 return NULL;
11300 }
11301
11302
11303 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11304 PyObject *resultobj;
11305 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11306 int arg2 ;
11307 PyObject * obj0 = 0 ;
11308 PyObject * obj1 = 0 ;
11309 char *kwnames[] = {
11310 (char *) "self",(char *) "m_pid", NULL
11311 };
11312
11313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11315 if (SWIG_arg_fail(1)) SWIG_fail;
11316 {
11317 arg2 = (int)(SWIG_As_int(obj1));
11318 if (SWIG_arg_fail(2)) SWIG_fail;
11319 }
11320 if (arg1) (arg1)->m_pid = arg2;
11321
11322 Py_INCREF(Py_None); resultobj = Py_None;
11323 return resultobj;
11324 fail:
11325 return NULL;
11326 }
11327
11328
11329 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11330 PyObject *resultobj;
11331 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11332 int result;
11333 PyObject * obj0 = 0 ;
11334 char *kwnames[] = {
11335 (char *) "self", NULL
11336 };
11337
11338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11340 if (SWIG_arg_fail(1)) SWIG_fail;
11341 result = (int) ((arg1)->m_pid);
11342
11343 {
11344 resultobj = SWIG_From_int((int)(result));
11345 }
11346 return resultobj;
11347 fail:
11348 return NULL;
11349 }
11350
11351
11352 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11353 PyObject *resultobj;
11354 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11355 int arg2 ;
11356 PyObject * obj0 = 0 ;
11357 PyObject * obj1 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "m_exitcode", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (int)(SWIG_As_int(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 if (arg1) (arg1)->m_exitcode = arg2;
11370
11371 Py_INCREF(Py_None); resultobj = Py_None;
11372 return resultobj;
11373 fail:
11374 return NULL;
11375 }
11376
11377
11378 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj;
11380 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11381 int result;
11382 PyObject * obj0 = 0 ;
11383 char *kwnames[] = {
11384 (char *) "self", NULL
11385 };
11386
11387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 result = (int) ((arg1)->m_exitcode);
11391
11392 {
11393 resultobj = SWIG_From_int((int)(result));
11394 }
11395 return resultobj;
11396 fail:
11397 return NULL;
11398 }
11399
11400
11401 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11402 PyObject *obj;
11403 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11404 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11405 Py_INCREF(obj);
11406 return Py_BuildValue((char *)"");
11407 }
11408 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11409 PyObject *resultobj;
11410 wxString *arg1 = 0 ;
11411 int arg2 = (int) wxEXEC_ASYNC ;
11412 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11413 long result;
11414 bool temp1 = false ;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 char *kwnames[] = {
11419 (char *) "command",(char *) "flags",(char *) "process", NULL
11420 };
11421
11422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11423 {
11424 arg1 = wxString_in_helper(obj0);
11425 if (arg1 == NULL) SWIG_fail;
11426 temp1 = true;
11427 }
11428 if (obj1) {
11429 {
11430 arg2 = (int)(SWIG_As_int(obj1));
11431 if (SWIG_arg_fail(2)) SWIG_fail;
11432 }
11433 }
11434 if (obj2) {
11435 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11436 if (SWIG_arg_fail(3)) SWIG_fail;
11437 }
11438 {
11439 if (!wxPyCheckForApp()) SWIG_fail;
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11442
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 {
11447 resultobj = SWIG_From_long((long)(result));
11448 }
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return resultobj;
11454 fail:
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return NULL;
11460 }
11461
11462
11463 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj;
11465 long arg1 ;
11466 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11467 wxKillError *arg3 = (wxKillError *) 0 ;
11468 int arg4 = (int) wxKILL_NOCHILDREN ;
11469 int result;
11470 wxKillError temp3 ;
11471 PyObject * obj0 = 0 ;
11472 PyObject * obj1 = 0 ;
11473 PyObject * obj2 = 0 ;
11474 char *kwnames[] = {
11475 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11476 };
11477
11478 {
11479 arg3 = &temp3;
11480 }
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11482 {
11483 arg1 = (long)(SWIG_As_long(obj0));
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 }
11486 if (obj1) {
11487 {
11488 arg2 = (wxSignal)(SWIG_As_int(obj1));
11489 if (SWIG_arg_fail(2)) SWIG_fail;
11490 }
11491 }
11492 if (obj2) {
11493 {
11494 arg4 = (int)(SWIG_As_int(obj2));
11495 if (SWIG_arg_fail(4)) SWIG_fail;
11496 }
11497 }
11498 {
11499 PyThreadState* __tstate = wxPyBeginAllowThreads();
11500 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11501
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 resultobj = SWIG_From_int((int)(result));
11507 }
11508 {
11509 PyObject* o;
11510 o = PyInt_FromLong((long) (*arg3));
11511 resultobj = t_output_helper(resultobj, o);
11512 }
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj;
11521 int arg1 = (int) wxJOYSTICK1 ;
11522 wxJoystick *result;
11523 PyObject * obj0 = 0 ;
11524 char *kwnames[] = {
11525 (char *) "joystick", NULL
11526 };
11527
11528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11529 if (obj0) {
11530 {
11531 arg1 = (int)(SWIG_As_int(obj0));
11532 if (SWIG_arg_fail(1)) SWIG_fail;
11533 }
11534 }
11535 {
11536 if (!wxPyCheckForApp()) SWIG_fail;
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (wxJoystick *)new wxJoystick(arg1);
11539
11540 wxPyEndAllowThreads(__tstate);
11541 if (PyErr_Occurred()) SWIG_fail;
11542 }
11543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj;
11552 wxJoystick *arg1 = (wxJoystick *) 0 ;
11553 PyObject * obj0 = 0 ;
11554 char *kwnames[] = {
11555 (char *) "self", NULL
11556 };
11557
11558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11560 if (SWIG_arg_fail(1)) SWIG_fail;
11561 {
11562 PyThreadState* __tstate = wxPyBeginAllowThreads();
11563 delete arg1;
11564
11565 wxPyEndAllowThreads(__tstate);
11566 if (PyErr_Occurred()) SWIG_fail;
11567 }
11568 Py_INCREF(Py_None); resultobj = Py_None;
11569 return resultobj;
11570 fail:
11571 return NULL;
11572 }
11573
11574
11575 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj;
11577 wxJoystick *arg1 = (wxJoystick *) 0 ;
11578 wxPoint result;
11579 PyObject * obj0 = 0 ;
11580 char *kwnames[] = {
11581 (char *) "self", NULL
11582 };
11583
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (arg1)->GetPosition();
11590
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 {
11595 wxPoint * resultptr;
11596 resultptr = new wxPoint((wxPoint &)(result));
11597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11598 }
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj;
11607 wxJoystick *arg1 = (wxJoystick *) 0 ;
11608 int result;
11609 PyObject * obj0 = 0 ;
11610 char *kwnames[] = {
11611 (char *) "self", NULL
11612 };
11613
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11616 if (SWIG_arg_fail(1)) SWIG_fail;
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 result = (int)(arg1)->GetZPosition();
11620
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 resultobj = SWIG_From_int((int)(result));
11626 }
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj;
11635 wxJoystick *arg1 = (wxJoystick *) 0 ;
11636 int result;
11637 PyObject * obj0 = 0 ;
11638 char *kwnames[] = {
11639 (char *) "self", NULL
11640 };
11641
11642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11644 if (SWIG_arg_fail(1)) SWIG_fail;
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (int)(arg1)->GetButtonState();
11648
11649 wxPyEndAllowThreads(__tstate);
11650 if (PyErr_Occurred()) SWIG_fail;
11651 }
11652 {
11653 resultobj = SWIG_From_int((int)(result));
11654 }
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxJoystick *arg1 = (wxJoystick *) 0 ;
11664 int result;
11665 PyObject * obj0 = 0 ;
11666 char *kwnames[] = {
11667 (char *) "self", NULL
11668 };
11669
11670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11672 if (SWIG_arg_fail(1)) SWIG_fail;
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 result = (int)(arg1)->GetPOVPosition();
11676
11677 wxPyEndAllowThreads(__tstate);
11678 if (PyErr_Occurred()) SWIG_fail;
11679 }
11680 {
11681 resultobj = SWIG_From_int((int)(result));
11682 }
11683 return resultobj;
11684 fail:
11685 return NULL;
11686 }
11687
11688
11689 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj;
11691 wxJoystick *arg1 = (wxJoystick *) 0 ;
11692 int result;
11693 PyObject * obj0 = 0 ;
11694 char *kwnames[] = {
11695 (char *) "self", NULL
11696 };
11697
11698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11700 if (SWIG_arg_fail(1)) SWIG_fail;
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (int)(arg1)->GetPOVCTSPosition();
11704
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 resultobj = SWIG_From_int((int)(result));
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11718 PyObject *resultobj;
11719 wxJoystick *arg1 = (wxJoystick *) 0 ;
11720 int result;
11721 PyObject * obj0 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "self", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11728 if (SWIG_arg_fail(1)) SWIG_fail;
11729 {
11730 PyThreadState* __tstate = wxPyBeginAllowThreads();
11731 result = (int)(arg1)->GetRudderPosition();
11732
11733 wxPyEndAllowThreads(__tstate);
11734 if (PyErr_Occurred()) SWIG_fail;
11735 }
11736 {
11737 resultobj = SWIG_From_int((int)(result));
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj;
11747 wxJoystick *arg1 = (wxJoystick *) 0 ;
11748 int result;
11749 PyObject * obj0 = 0 ;
11750 char *kwnames[] = {
11751 (char *) "self", NULL
11752 };
11753
11754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11756 if (SWIG_arg_fail(1)) SWIG_fail;
11757 {
11758 PyThreadState* __tstate = wxPyBeginAllowThreads();
11759 result = (int)(arg1)->GetUPosition();
11760
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 {
11765 resultobj = SWIG_From_int((int)(result));
11766 }
11767 return resultobj;
11768 fail:
11769 return NULL;
11770 }
11771
11772
11773 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11774 PyObject *resultobj;
11775 wxJoystick *arg1 = (wxJoystick *) 0 ;
11776 int result;
11777 PyObject * obj0 = 0 ;
11778 char *kwnames[] = {
11779 (char *) "self", NULL
11780 };
11781
11782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11784 if (SWIG_arg_fail(1)) SWIG_fail;
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 result = (int)(arg1)->GetVPosition();
11788
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 resultobj = SWIG_From_int((int)(result));
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11802 PyObject *resultobj;
11803 wxJoystick *arg1 = (wxJoystick *) 0 ;
11804 int result;
11805 PyObject * obj0 = 0 ;
11806 char *kwnames[] = {
11807 (char *) "self", NULL
11808 };
11809
11810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11812 if (SWIG_arg_fail(1)) SWIG_fail;
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 result = (int)(arg1)->GetMovementThreshold();
11816
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 {
11821 resultobj = SWIG_From_int((int)(result));
11822 }
11823 return resultobj;
11824 fail:
11825 return NULL;
11826 }
11827
11828
11829 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11830 PyObject *resultobj;
11831 wxJoystick *arg1 = (wxJoystick *) 0 ;
11832 int arg2 ;
11833 PyObject * obj0 = 0 ;
11834 PyObject * obj1 = 0 ;
11835 char *kwnames[] = {
11836 (char *) "self",(char *) "threshold", NULL
11837 };
11838
11839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11841 if (SWIG_arg_fail(1)) SWIG_fail;
11842 {
11843 arg2 = (int)(SWIG_As_int(obj1));
11844 if (SWIG_arg_fail(2)) SWIG_fail;
11845 }
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 (arg1)->SetMovementThreshold(arg2);
11849
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 Py_INCREF(Py_None); resultobj = Py_None;
11854 return resultobj;
11855 fail:
11856 return NULL;
11857 }
11858
11859
11860 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj;
11862 wxJoystick *arg1 = (wxJoystick *) 0 ;
11863 bool result;
11864 PyObject * obj0 = 0 ;
11865 char *kwnames[] = {
11866 (char *) "self", NULL
11867 };
11868
11869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11871 if (SWIG_arg_fail(1)) SWIG_fail;
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (bool)(arg1)->IsOk();
11875
11876 wxPyEndAllowThreads(__tstate);
11877 if (PyErr_Occurred()) SWIG_fail;
11878 }
11879 {
11880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11881 }
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj;
11890 wxJoystick *arg1 = (wxJoystick *) 0 ;
11891 int result;
11892 PyObject * obj0 = 0 ;
11893 char *kwnames[] = {
11894 (char *) "self", NULL
11895 };
11896
11897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11899 if (SWIG_arg_fail(1)) SWIG_fail;
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (int)(arg1)->GetNumberJoysticks();
11903
11904 wxPyEndAllowThreads(__tstate);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 {
11908 resultobj = SWIG_From_int((int)(result));
11909 }
11910 return resultobj;
11911 fail:
11912 return NULL;
11913 }
11914
11915
11916 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj;
11918 wxJoystick *arg1 = (wxJoystick *) 0 ;
11919 int result;
11920 PyObject * obj0 = 0 ;
11921 char *kwnames[] = {
11922 (char *) "self", NULL
11923 };
11924
11925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11927 if (SWIG_arg_fail(1)) SWIG_fail;
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 result = (int)(arg1)->GetManufacturerId();
11931
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 {
11936 resultobj = SWIG_From_int((int)(result));
11937 }
11938 return resultobj;
11939 fail:
11940 return NULL;
11941 }
11942
11943
11944 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11945 PyObject *resultobj;
11946 wxJoystick *arg1 = (wxJoystick *) 0 ;
11947 int result;
11948 PyObject * obj0 = 0 ;
11949 char *kwnames[] = {
11950 (char *) "self", NULL
11951 };
11952
11953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11955 if (SWIG_arg_fail(1)) SWIG_fail;
11956 {
11957 PyThreadState* __tstate = wxPyBeginAllowThreads();
11958 result = (int)(arg1)->GetProductId();
11959
11960 wxPyEndAllowThreads(__tstate);
11961 if (PyErr_Occurred()) SWIG_fail;
11962 }
11963 {
11964 resultobj = SWIG_From_int((int)(result));
11965 }
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj;
11974 wxJoystick *arg1 = (wxJoystick *) 0 ;
11975 wxString result;
11976 PyObject * obj0 = 0 ;
11977 char *kwnames[] = {
11978 (char *) "self", NULL
11979 };
11980
11981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11983 if (SWIG_arg_fail(1)) SWIG_fail;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (arg1)->GetProductName();
11987
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 {
11992 #if wxUSE_UNICODE
11993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11994 #else
11995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11996 #endif
11997 }
11998 return resultobj;
11999 fail:
12000 return NULL;
12001 }
12002
12003
12004 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12005 PyObject *resultobj;
12006 wxJoystick *arg1 = (wxJoystick *) 0 ;
12007 int result;
12008 PyObject * obj0 = 0 ;
12009 char *kwnames[] = {
12010 (char *) "self", NULL
12011 };
12012
12013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12015 if (SWIG_arg_fail(1)) SWIG_fail;
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 result = (int)(arg1)->GetXMin();
12019
12020 wxPyEndAllowThreads(__tstate);
12021 if (PyErr_Occurred()) SWIG_fail;
12022 }
12023 {
12024 resultobj = SWIG_From_int((int)(result));
12025 }
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj;
12034 wxJoystick *arg1 = (wxJoystick *) 0 ;
12035 int result;
12036 PyObject * obj0 = 0 ;
12037 char *kwnames[] = {
12038 (char *) "self", NULL
12039 };
12040
12041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12043 if (SWIG_arg_fail(1)) SWIG_fail;
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (int)(arg1)->GetYMin();
12047
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 {
12052 resultobj = SWIG_From_int((int)(result));
12053 }
12054 return resultobj;
12055 fail:
12056 return NULL;
12057 }
12058
12059
12060 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12061 PyObject *resultobj;
12062 wxJoystick *arg1 = (wxJoystick *) 0 ;
12063 int result;
12064 PyObject * obj0 = 0 ;
12065 char *kwnames[] = {
12066 (char *) "self", NULL
12067 };
12068
12069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12071 if (SWIG_arg_fail(1)) SWIG_fail;
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 result = (int)(arg1)->GetZMin();
12075
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 {
12080 resultobj = SWIG_From_int((int)(result));
12081 }
12082 return resultobj;
12083 fail:
12084 return NULL;
12085 }
12086
12087
12088 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj;
12090 wxJoystick *arg1 = (wxJoystick *) 0 ;
12091 int result;
12092 PyObject * obj0 = 0 ;
12093 char *kwnames[] = {
12094 (char *) "self", NULL
12095 };
12096
12097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12099 if (SWIG_arg_fail(1)) SWIG_fail;
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 result = (int)(arg1)->GetXMax();
12103
12104 wxPyEndAllowThreads(__tstate);
12105 if (PyErr_Occurred()) SWIG_fail;
12106 }
12107 {
12108 resultobj = SWIG_From_int((int)(result));
12109 }
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj;
12118 wxJoystick *arg1 = (wxJoystick *) 0 ;
12119 int result;
12120 PyObject * obj0 = 0 ;
12121 char *kwnames[] = {
12122 (char *) "self", NULL
12123 };
12124
12125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12127 if (SWIG_arg_fail(1)) SWIG_fail;
12128 {
12129 PyThreadState* __tstate = wxPyBeginAllowThreads();
12130 result = (int)(arg1)->GetYMax();
12131
12132 wxPyEndAllowThreads(__tstate);
12133 if (PyErr_Occurred()) SWIG_fail;
12134 }
12135 {
12136 resultobj = SWIG_From_int((int)(result));
12137 }
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12145 PyObject *resultobj;
12146 wxJoystick *arg1 = (wxJoystick *) 0 ;
12147 int result;
12148 PyObject * obj0 = 0 ;
12149 char *kwnames[] = {
12150 (char *) "self", NULL
12151 };
12152
12153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12155 if (SWIG_arg_fail(1)) SWIG_fail;
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 result = (int)(arg1)->GetZMax();
12159
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 {
12164 resultobj = SWIG_From_int((int)(result));
12165 }
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12173 PyObject *resultobj;
12174 wxJoystick *arg1 = (wxJoystick *) 0 ;
12175 int result;
12176 PyObject * obj0 = 0 ;
12177 char *kwnames[] = {
12178 (char *) "self", NULL
12179 };
12180
12181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12183 if (SWIG_arg_fail(1)) SWIG_fail;
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 result = (int)(arg1)->GetNumberButtons();
12187
12188 wxPyEndAllowThreads(__tstate);
12189 if (PyErr_Occurred()) SWIG_fail;
12190 }
12191 {
12192 resultobj = SWIG_From_int((int)(result));
12193 }
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj;
12202 wxJoystick *arg1 = (wxJoystick *) 0 ;
12203 int result;
12204 PyObject * obj0 = 0 ;
12205 char *kwnames[] = {
12206 (char *) "self", NULL
12207 };
12208
12209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12211 if (SWIG_arg_fail(1)) SWIG_fail;
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (int)(arg1)->GetNumberAxes();
12215
12216 wxPyEndAllowThreads(__tstate);
12217 if (PyErr_Occurred()) SWIG_fail;
12218 }
12219 {
12220 resultobj = SWIG_From_int((int)(result));
12221 }
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj;
12230 wxJoystick *arg1 = (wxJoystick *) 0 ;
12231 int result;
12232 PyObject * obj0 = 0 ;
12233 char *kwnames[] = {
12234 (char *) "self", NULL
12235 };
12236
12237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12239 if (SWIG_arg_fail(1)) SWIG_fail;
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = (int)(arg1)->GetMaxButtons();
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 {
12248 resultobj = SWIG_From_int((int)(result));
12249 }
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj;
12258 wxJoystick *arg1 = (wxJoystick *) 0 ;
12259 int result;
12260 PyObject * obj0 = 0 ;
12261 char *kwnames[] = {
12262 (char *) "self", NULL
12263 };
12264
12265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12267 if (SWIG_arg_fail(1)) SWIG_fail;
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 result = (int)(arg1)->GetMaxAxes();
12271
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 {
12276 resultobj = SWIG_From_int((int)(result));
12277 }
12278 return resultobj;
12279 fail:
12280 return NULL;
12281 }
12282
12283
12284 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj;
12286 wxJoystick *arg1 = (wxJoystick *) 0 ;
12287 int result;
12288 PyObject * obj0 = 0 ;
12289 char *kwnames[] = {
12290 (char *) "self", NULL
12291 };
12292
12293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12295 if (SWIG_arg_fail(1)) SWIG_fail;
12296 {
12297 PyThreadState* __tstate = wxPyBeginAllowThreads();
12298 result = (int)(arg1)->GetPollingMin();
12299
12300 wxPyEndAllowThreads(__tstate);
12301 if (PyErr_Occurred()) SWIG_fail;
12302 }
12303 {
12304 resultobj = SWIG_From_int((int)(result));
12305 }
12306 return resultobj;
12307 fail:
12308 return NULL;
12309 }
12310
12311
12312 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12313 PyObject *resultobj;
12314 wxJoystick *arg1 = (wxJoystick *) 0 ;
12315 int result;
12316 PyObject * obj0 = 0 ;
12317 char *kwnames[] = {
12318 (char *) "self", NULL
12319 };
12320
12321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12323 if (SWIG_arg_fail(1)) SWIG_fail;
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 result = (int)(arg1)->GetPollingMax();
12327
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 {
12332 resultobj = SWIG_From_int((int)(result));
12333 }
12334 return resultobj;
12335 fail:
12336 return NULL;
12337 }
12338
12339
12340 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj;
12342 wxJoystick *arg1 = (wxJoystick *) 0 ;
12343 int result;
12344 PyObject * obj0 = 0 ;
12345 char *kwnames[] = {
12346 (char *) "self", NULL
12347 };
12348
12349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12351 if (SWIG_arg_fail(1)) SWIG_fail;
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (int)(arg1)->GetRudderMin();
12355
12356 wxPyEndAllowThreads(__tstate);
12357 if (PyErr_Occurred()) SWIG_fail;
12358 }
12359 {
12360 resultobj = SWIG_From_int((int)(result));
12361 }
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12369 PyObject *resultobj;
12370 wxJoystick *arg1 = (wxJoystick *) 0 ;
12371 int result;
12372 PyObject * obj0 = 0 ;
12373 char *kwnames[] = {
12374 (char *) "self", NULL
12375 };
12376
12377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12379 if (SWIG_arg_fail(1)) SWIG_fail;
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 result = (int)(arg1)->GetRudderMax();
12383
12384 wxPyEndAllowThreads(__tstate);
12385 if (PyErr_Occurred()) SWIG_fail;
12386 }
12387 {
12388 resultobj = SWIG_From_int((int)(result));
12389 }
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12397 PyObject *resultobj;
12398 wxJoystick *arg1 = (wxJoystick *) 0 ;
12399 int result;
12400 PyObject * obj0 = 0 ;
12401 char *kwnames[] = {
12402 (char *) "self", NULL
12403 };
12404
12405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12407 if (SWIG_arg_fail(1)) SWIG_fail;
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = (int)(arg1)->GetUMin();
12411
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 {
12416 resultobj = SWIG_From_int((int)(result));
12417 }
12418 return resultobj;
12419 fail:
12420 return NULL;
12421 }
12422
12423
12424 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12425 PyObject *resultobj;
12426 wxJoystick *arg1 = (wxJoystick *) 0 ;
12427 int result;
12428 PyObject * obj0 = 0 ;
12429 char *kwnames[] = {
12430 (char *) "self", NULL
12431 };
12432
12433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12435 if (SWIG_arg_fail(1)) SWIG_fail;
12436 {
12437 PyThreadState* __tstate = wxPyBeginAllowThreads();
12438 result = (int)(arg1)->GetUMax();
12439
12440 wxPyEndAllowThreads(__tstate);
12441 if (PyErr_Occurred()) SWIG_fail;
12442 }
12443 {
12444 resultobj = SWIG_From_int((int)(result));
12445 }
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj;
12454 wxJoystick *arg1 = (wxJoystick *) 0 ;
12455 int result;
12456 PyObject * obj0 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 result = (int)(arg1)->GetVMin();
12467
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 {
12472 resultobj = SWIG_From_int((int)(result));
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12481 PyObject *resultobj;
12482 wxJoystick *arg1 = (wxJoystick *) 0 ;
12483 int result;
12484 PyObject * obj0 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 result = (int)(arg1)->GetVMax();
12495
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 {
12500 resultobj = SWIG_From_int((int)(result));
12501 }
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj;
12510 wxJoystick *arg1 = (wxJoystick *) 0 ;
12511 bool result;
12512 PyObject * obj0 = 0 ;
12513 char *kwnames[] = {
12514 (char *) "self", NULL
12515 };
12516
12517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12519 if (SWIG_arg_fail(1)) SWIG_fail;
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 result = (bool)(arg1)->HasRudder();
12523
12524 wxPyEndAllowThreads(__tstate);
12525 if (PyErr_Occurred()) SWIG_fail;
12526 }
12527 {
12528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj;
12538 wxJoystick *arg1 = (wxJoystick *) 0 ;
12539 bool result;
12540 PyObject * obj0 = 0 ;
12541 char *kwnames[] = {
12542 (char *) "self", NULL
12543 };
12544
12545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12547 if (SWIG_arg_fail(1)) SWIG_fail;
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 result = (bool)(arg1)->HasZ();
12551
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 {
12556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12557 }
12558 return resultobj;
12559 fail:
12560 return NULL;
12561 }
12562
12563
12564 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12565 PyObject *resultobj;
12566 wxJoystick *arg1 = (wxJoystick *) 0 ;
12567 bool result;
12568 PyObject * obj0 = 0 ;
12569 char *kwnames[] = {
12570 (char *) "self", NULL
12571 };
12572
12573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12575 if (SWIG_arg_fail(1)) SWIG_fail;
12576 {
12577 PyThreadState* __tstate = wxPyBeginAllowThreads();
12578 result = (bool)(arg1)->HasU();
12579
12580 wxPyEndAllowThreads(__tstate);
12581 if (PyErr_Occurred()) SWIG_fail;
12582 }
12583 {
12584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12585 }
12586 return resultobj;
12587 fail:
12588 return NULL;
12589 }
12590
12591
12592 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12593 PyObject *resultobj;
12594 wxJoystick *arg1 = (wxJoystick *) 0 ;
12595 bool result;
12596 PyObject * obj0 = 0 ;
12597 char *kwnames[] = {
12598 (char *) "self", NULL
12599 };
12600
12601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12603 if (SWIG_arg_fail(1)) SWIG_fail;
12604 {
12605 PyThreadState* __tstate = wxPyBeginAllowThreads();
12606 result = (bool)(arg1)->HasV();
12607
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12613 }
12614 return resultobj;
12615 fail:
12616 return NULL;
12617 }
12618
12619
12620 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12621 PyObject *resultobj;
12622 wxJoystick *arg1 = (wxJoystick *) 0 ;
12623 bool result;
12624 PyObject * obj0 = 0 ;
12625 char *kwnames[] = {
12626 (char *) "self", NULL
12627 };
12628
12629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12631 if (SWIG_arg_fail(1)) SWIG_fail;
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (bool)(arg1)->HasPOV();
12635
12636 wxPyEndAllowThreads(__tstate);
12637 if (PyErr_Occurred()) SWIG_fail;
12638 }
12639 {
12640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12641 }
12642 return resultobj;
12643 fail:
12644 return NULL;
12645 }
12646
12647
12648 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12649 PyObject *resultobj;
12650 wxJoystick *arg1 = (wxJoystick *) 0 ;
12651 bool result;
12652 PyObject * obj0 = 0 ;
12653 char *kwnames[] = {
12654 (char *) "self", NULL
12655 };
12656
12657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12659 if (SWIG_arg_fail(1)) SWIG_fail;
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = (bool)(arg1)->HasPOV4Dir();
12663
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 {
12668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12669 }
12670 return resultobj;
12671 fail:
12672 return NULL;
12673 }
12674
12675
12676 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12677 PyObject *resultobj;
12678 wxJoystick *arg1 = (wxJoystick *) 0 ;
12679 bool result;
12680 PyObject * obj0 = 0 ;
12681 char *kwnames[] = {
12682 (char *) "self", NULL
12683 };
12684
12685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12687 if (SWIG_arg_fail(1)) SWIG_fail;
12688 {
12689 PyThreadState* __tstate = wxPyBeginAllowThreads();
12690 result = (bool)(arg1)->HasPOVCTS();
12691
12692 wxPyEndAllowThreads(__tstate);
12693 if (PyErr_Occurred()) SWIG_fail;
12694 }
12695 {
12696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12697 }
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj;
12706 wxJoystick *arg1 = (wxJoystick *) 0 ;
12707 wxWindow *arg2 = (wxWindow *) 0 ;
12708 int arg3 = (int) 0 ;
12709 bool result;
12710 PyObject * obj0 = 0 ;
12711 PyObject * obj1 = 0 ;
12712 PyObject * obj2 = 0 ;
12713 char *kwnames[] = {
12714 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12715 };
12716
12717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12719 if (SWIG_arg_fail(1)) SWIG_fail;
12720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12721 if (SWIG_arg_fail(2)) SWIG_fail;
12722 if (obj2) {
12723 {
12724 arg3 = (int)(SWIG_As_int(obj2));
12725 if (SWIG_arg_fail(3)) SWIG_fail;
12726 }
12727 }
12728 {
12729 PyThreadState* __tstate = wxPyBeginAllowThreads();
12730 result = (bool)(arg1)->SetCapture(arg2,arg3);
12731
12732 wxPyEndAllowThreads(__tstate);
12733 if (PyErr_Occurred()) SWIG_fail;
12734 }
12735 {
12736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12737 }
12738 return resultobj;
12739 fail:
12740 return NULL;
12741 }
12742
12743
12744 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12745 PyObject *resultobj;
12746 wxJoystick *arg1 = (wxJoystick *) 0 ;
12747 bool result;
12748 PyObject * obj0 = 0 ;
12749 char *kwnames[] = {
12750 (char *) "self", NULL
12751 };
12752
12753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12755 if (SWIG_arg_fail(1)) SWIG_fail;
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 result = (bool)(arg1)->ReleaseCapture();
12759
12760 wxPyEndAllowThreads(__tstate);
12761 if (PyErr_Occurred()) SWIG_fail;
12762 }
12763 {
12764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12765 }
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12773 PyObject *obj;
12774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12775 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12776 Py_INCREF(obj);
12777 return Py_BuildValue((char *)"");
12778 }
12779 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj;
12781 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12782 int arg2 = (int) 0 ;
12783 int arg3 = (int) wxJOYSTICK1 ;
12784 int arg4 = (int) 0 ;
12785 wxJoystickEvent *result;
12786 PyObject * obj0 = 0 ;
12787 PyObject * obj1 = 0 ;
12788 PyObject * obj2 = 0 ;
12789 PyObject * obj3 = 0 ;
12790 char *kwnames[] = {
12791 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12792 };
12793
12794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12795 if (obj0) {
12796 {
12797 arg1 = (wxEventType)(SWIG_As_int(obj0));
12798 if (SWIG_arg_fail(1)) SWIG_fail;
12799 }
12800 }
12801 if (obj1) {
12802 {
12803 arg2 = (int)(SWIG_As_int(obj1));
12804 if (SWIG_arg_fail(2)) SWIG_fail;
12805 }
12806 }
12807 if (obj2) {
12808 {
12809 arg3 = (int)(SWIG_As_int(obj2));
12810 if (SWIG_arg_fail(3)) SWIG_fail;
12811 }
12812 }
12813 if (obj3) {
12814 {
12815 arg4 = (int)(SWIG_As_int(obj3));
12816 if (SWIG_arg_fail(4)) SWIG_fail;
12817 }
12818 }
12819 {
12820 PyThreadState* __tstate = wxPyBeginAllowThreads();
12821 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12822
12823 wxPyEndAllowThreads(__tstate);
12824 if (PyErr_Occurred()) SWIG_fail;
12825 }
12826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj;
12835 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12836 wxPoint result;
12837 PyObject * obj0 = 0 ;
12838 char *kwnames[] = {
12839 (char *) "self", NULL
12840 };
12841
12842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12844 if (SWIG_arg_fail(1)) SWIG_fail;
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12848
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 {
12853 wxPoint * resultptr;
12854 resultptr = new wxPoint((wxPoint &)(result));
12855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj;
12865 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12866 int result;
12867 PyObject * obj0 = 0 ;
12868 char *kwnames[] = {
12869 (char *) "self", NULL
12870 };
12871
12872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12874 if (SWIG_arg_fail(1)) SWIG_fail;
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12878
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 {
12883 resultobj = SWIG_From_int((int)(result));
12884 }
12885 return resultobj;
12886 fail:
12887 return NULL;
12888 }
12889
12890
12891 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12892 PyObject *resultobj;
12893 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12894 int result;
12895 PyObject * obj0 = 0 ;
12896 char *kwnames[] = {
12897 (char *) "self", NULL
12898 };
12899
12900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12902 if (SWIG_arg_fail(1)) SWIG_fail;
12903 {
12904 PyThreadState* __tstate = wxPyBeginAllowThreads();
12905 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12906
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 {
12911 resultobj = SWIG_From_int((int)(result));
12912 }
12913 return resultobj;
12914 fail:
12915 return NULL;
12916 }
12917
12918
12919 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12920 PyObject *resultobj;
12921 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12922 int result;
12923 PyObject * obj0 = 0 ;
12924 char *kwnames[] = {
12925 (char *) "self", NULL
12926 };
12927
12928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12930 if (SWIG_arg_fail(1)) SWIG_fail;
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12934
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 {
12939 resultobj = SWIG_From_int((int)(result));
12940 }
12941 return resultobj;
12942 fail:
12943 return NULL;
12944 }
12945
12946
12947 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12948 PyObject *resultobj;
12949 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12950 int result;
12951 PyObject * obj0 = 0 ;
12952 char *kwnames[] = {
12953 (char *) "self", NULL
12954 };
12955
12956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12958 if (SWIG_arg_fail(1)) SWIG_fail;
12959 {
12960 PyThreadState* __tstate = wxPyBeginAllowThreads();
12961 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12962
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
12965 }
12966 {
12967 resultobj = SWIG_From_int((int)(result));
12968 }
12969 return resultobj;
12970 fail:
12971 return NULL;
12972 }
12973
12974
12975 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12976 PyObject *resultobj;
12977 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12978 int arg2 ;
12979 PyObject * obj0 = 0 ;
12980 PyObject * obj1 = 0 ;
12981 char *kwnames[] = {
12982 (char *) "self",(char *) "stick", NULL
12983 };
12984
12985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12987 if (SWIG_arg_fail(1)) SWIG_fail;
12988 {
12989 arg2 = (int)(SWIG_As_int(obj1));
12990 if (SWIG_arg_fail(2)) SWIG_fail;
12991 }
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 (arg1)->SetJoystick(arg2);
12995
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 Py_INCREF(Py_None); resultobj = Py_None;
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj;
13008 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13009 int arg2 ;
13010 PyObject * obj0 = 0 ;
13011 PyObject * obj1 = 0 ;
13012 char *kwnames[] = {
13013 (char *) "self",(char *) "state", NULL
13014 };
13015
13016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13018 if (SWIG_arg_fail(1)) SWIG_fail;
13019 {
13020 arg2 = (int)(SWIG_As_int(obj1));
13021 if (SWIG_arg_fail(2)) SWIG_fail;
13022 }
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 (arg1)->SetButtonState(arg2);
13026
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 Py_INCREF(Py_None); resultobj = Py_None;
13031 return resultobj;
13032 fail:
13033 return NULL;
13034 }
13035
13036
13037 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13038 PyObject *resultobj;
13039 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13040 int arg2 ;
13041 PyObject * obj0 = 0 ;
13042 PyObject * obj1 = 0 ;
13043 char *kwnames[] = {
13044 (char *) "self",(char *) "change", NULL
13045 };
13046
13047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13049 if (SWIG_arg_fail(1)) SWIG_fail;
13050 {
13051 arg2 = (int)(SWIG_As_int(obj1));
13052 if (SWIG_arg_fail(2)) SWIG_fail;
13053 }
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 (arg1)->SetButtonChange(arg2);
13057
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 Py_INCREF(Py_None); resultobj = Py_None;
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13069 PyObject *resultobj;
13070 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13071 wxPoint *arg2 = 0 ;
13072 wxPoint temp2 ;
13073 PyObject * obj0 = 0 ;
13074 PyObject * obj1 = 0 ;
13075 char *kwnames[] = {
13076 (char *) "self",(char *) "pos", NULL
13077 };
13078
13079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13081 if (SWIG_arg_fail(1)) SWIG_fail;
13082 {
13083 arg2 = &temp2;
13084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13085 }
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 (arg1)->SetPosition((wxPoint const &)*arg2);
13089
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 Py_INCREF(Py_None); resultobj = Py_None;
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13101 PyObject *resultobj;
13102 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13103 int arg2 ;
13104 PyObject * obj0 = 0 ;
13105 PyObject * obj1 = 0 ;
13106 char *kwnames[] = {
13107 (char *) "self",(char *) "zPos", NULL
13108 };
13109
13110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13112 if (SWIG_arg_fail(1)) SWIG_fail;
13113 {
13114 arg2 = (int)(SWIG_As_int(obj1));
13115 if (SWIG_arg_fail(2)) SWIG_fail;
13116 }
13117 {
13118 PyThreadState* __tstate = wxPyBeginAllowThreads();
13119 (arg1)->SetZPosition(arg2);
13120
13121 wxPyEndAllowThreads(__tstate);
13122 if (PyErr_Occurred()) SWIG_fail;
13123 }
13124 Py_INCREF(Py_None); resultobj = Py_None;
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj;
13133 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13134 bool result;
13135 PyObject * obj0 = 0 ;
13136 char *kwnames[] = {
13137 (char *) "self", NULL
13138 };
13139
13140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",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 = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13146
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 {
13151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13152 }
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj;
13161 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13162 bool result;
13163 PyObject * obj0 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "self", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",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 = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 {
13179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13190 bool result;
13191 PyObject * obj0 = 0 ;
13192 char *kwnames[] = {
13193 (char *) "self", NULL
13194 };
13195
13196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13198 if (SWIG_arg_fail(1)) SWIG_fail;
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13202
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 {
13207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13208 }
13209 return resultobj;
13210 fail:
13211 return NULL;
13212 }
13213
13214
13215 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj;
13217 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13218 int arg2 = (int) wxJOY_BUTTON_ANY ;
13219 bool result;
13220 PyObject * obj0 = 0 ;
13221 PyObject * obj1 = 0 ;
13222 char *kwnames[] = {
13223 (char *) "self",(char *) "but", NULL
13224 };
13225
13226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13228 if (SWIG_arg_fail(1)) SWIG_fail;
13229 if (obj1) {
13230 {
13231 arg2 = (int)(SWIG_As_int(obj1));
13232 if (SWIG_arg_fail(2)) SWIG_fail;
13233 }
13234 }
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13238
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 {
13243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13244 }
13245 return resultobj;
13246 fail:
13247 return NULL;
13248 }
13249
13250
13251 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj;
13253 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13254 int arg2 = (int) wxJOY_BUTTON_ANY ;
13255 bool result;
13256 PyObject * obj0 = 0 ;
13257 PyObject * obj1 = 0 ;
13258 char *kwnames[] = {
13259 (char *) "self",(char *) "but", NULL
13260 };
13261
13262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13264 if (SWIG_arg_fail(1)) SWIG_fail;
13265 if (obj1) {
13266 {
13267 arg2 = (int)(SWIG_As_int(obj1));
13268 if (SWIG_arg_fail(2)) SWIG_fail;
13269 }
13270 }
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13274
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13280 }
13281 return resultobj;
13282 fail:
13283 return NULL;
13284 }
13285
13286
13287 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13288 PyObject *resultobj;
13289 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13290 int arg2 = (int) wxJOY_BUTTON_ANY ;
13291 bool result;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 char *kwnames[] = {
13295 (char *) "self",(char *) "but", NULL
13296 };
13297
13298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13300 if (SWIG_arg_fail(1)) SWIG_fail;
13301 if (obj1) {
13302 {
13303 arg2 = (int)(SWIG_As_int(obj1));
13304 if (SWIG_arg_fail(2)) SWIG_fail;
13305 }
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 {
13315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13316 }
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13324 PyObject *obj;
13325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13326 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13327 Py_INCREF(obj);
13328 return Py_BuildValue((char *)"");
13329 }
13330 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj;
13332 wxString const &arg1_defvalue = wxPyEmptyString ;
13333 wxString *arg1 = (wxString *) &arg1_defvalue ;
13334 wxSound *result;
13335 bool temp1 = false ;
13336 PyObject * obj0 = 0 ;
13337 char *kwnames[] = {
13338 (char *) "fileName", NULL
13339 };
13340
13341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13342 if (obj0) {
13343 {
13344 arg1 = wxString_in_helper(obj0);
13345 if (arg1 == NULL) SWIG_fail;
13346 temp1 = true;
13347 }
13348 }
13349 {
13350 if (!wxPyCheckForApp()) SWIG_fail;
13351 PyThreadState* __tstate = wxPyBeginAllowThreads();
13352 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13353
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13358 {
13359 if (temp1)
13360 delete arg1;
13361 }
13362 return resultobj;
13363 fail:
13364 {
13365 if (temp1)
13366 delete arg1;
13367 }
13368 return NULL;
13369 }
13370
13371
13372 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13373 PyObject *resultobj;
13374 PyObject *arg1 = (PyObject *) 0 ;
13375 wxSound *result;
13376 PyObject * obj0 = 0 ;
13377 char *kwnames[] = {
13378 (char *) "data", NULL
13379 };
13380
13381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13382 arg1 = obj0;
13383 {
13384 if (!wxPyCheckForApp()) SWIG_fail;
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 result = (wxSound *)new_wxSound(arg1);
13387
13388 wxPyEndAllowThreads(__tstate);
13389 if (PyErr_Occurred()) SWIG_fail;
13390 }
13391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13392 return resultobj;
13393 fail:
13394 return NULL;
13395 }
13396
13397
13398 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13399 PyObject *resultobj;
13400 wxSound *arg1 = (wxSound *) 0 ;
13401 PyObject * obj0 = 0 ;
13402 char *kwnames[] = {
13403 (char *) "self", NULL
13404 };
13405
13406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13408 if (SWIG_arg_fail(1)) SWIG_fail;
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 delete arg1;
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 Py_INCREF(Py_None); resultobj = Py_None;
13417 return resultobj;
13418 fail:
13419 return NULL;
13420 }
13421
13422
13423 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13424 PyObject *resultobj;
13425 wxSound *arg1 = (wxSound *) 0 ;
13426 wxString *arg2 = 0 ;
13427 bool result;
13428 bool temp2 = false ;
13429 PyObject * obj0 = 0 ;
13430 PyObject * obj1 = 0 ;
13431 char *kwnames[] = {
13432 (char *) "self",(char *) "fileName", NULL
13433 };
13434
13435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13437 if (SWIG_arg_fail(1)) SWIG_fail;
13438 {
13439 arg2 = wxString_in_helper(obj1);
13440 if (arg2 == NULL) SWIG_fail;
13441 temp2 = true;
13442 }
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 result = (bool)(arg1)->Create((wxString const &)*arg2);
13446
13447 wxPyEndAllowThreads(__tstate);
13448 if (PyErr_Occurred()) SWIG_fail;
13449 }
13450 {
13451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13452 }
13453 {
13454 if (temp2)
13455 delete arg2;
13456 }
13457 return resultobj;
13458 fail:
13459 {
13460 if (temp2)
13461 delete arg2;
13462 }
13463 return NULL;
13464 }
13465
13466
13467 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj;
13469 wxSound *arg1 = (wxSound *) 0 ;
13470 PyObject *arg2 = (PyObject *) 0 ;
13471 bool result;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char *kwnames[] = {
13475 (char *) "self",(char *) "data", NULL
13476 };
13477
13478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13480 if (SWIG_arg_fail(1)) SWIG_fail;
13481 arg2 = obj1;
13482 {
13483 PyThreadState* __tstate = wxPyBeginAllowThreads();
13484 result = (bool)wxSound_CreateFromData(arg1,arg2);
13485
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13499 PyObject *resultobj;
13500 wxSound *arg1 = (wxSound *) 0 ;
13501 bool result;
13502 PyObject * obj0 = 0 ;
13503 char *kwnames[] = {
13504 (char *) "self", NULL
13505 };
13506
13507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13509 if (SWIG_arg_fail(1)) SWIG_fail;
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 result = (bool)(arg1)->IsOk();
13513
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 {
13518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13519 }
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj;
13528 wxSound *arg1 = (wxSound *) 0 ;
13529 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13530 bool result;
13531 PyObject * obj0 = 0 ;
13532 PyObject * obj1 = 0 ;
13533 char *kwnames[] = {
13534 (char *) "self",(char *) "flags", NULL
13535 };
13536
13537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13539 if (SWIG_arg_fail(1)) SWIG_fail;
13540 if (obj1) {
13541 {
13542 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13543 if (SWIG_arg_fail(2)) SWIG_fail;
13544 }
13545 }
13546 {
13547 if (!wxPyCheckForApp()) SWIG_fail;
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 result = (bool)((wxSound const *)arg1)->Play(arg2);
13550
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 {
13555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13556 }
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13564 PyObject *resultobj;
13565 wxString *arg1 = 0 ;
13566 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13567 bool result;
13568 bool temp1 = false ;
13569 PyObject * obj0 = 0 ;
13570 PyObject * obj1 = 0 ;
13571 char *kwnames[] = {
13572 (char *) "filename",(char *) "flags", NULL
13573 };
13574
13575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13576 {
13577 arg1 = wxString_in_helper(obj0);
13578 if (arg1 == NULL) SWIG_fail;
13579 temp1 = true;
13580 }
13581 if (obj1) {
13582 {
13583 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13584 if (SWIG_arg_fail(2)) SWIG_fail;
13585 }
13586 }
13587 {
13588 if (!wxPyCheckForApp()) SWIG_fail;
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13591
13592 wxPyEndAllowThreads(__tstate);
13593 if (PyErr_Occurred()) SWIG_fail;
13594 }
13595 {
13596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13597 }
13598 {
13599 if (temp1)
13600 delete arg1;
13601 }
13602 return resultobj;
13603 fail:
13604 {
13605 if (temp1)
13606 delete arg1;
13607 }
13608 return NULL;
13609 }
13610
13611
13612 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj;
13614 char *kwnames[] = {
13615 NULL
13616 };
13617
13618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13619 {
13620 if (!wxPyCheckForApp()) SWIG_fail;
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 wxSound::Stop();
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13635 PyObject *obj;
13636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13637 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13638 Py_INCREF(obj);
13639 return Py_BuildValue((char *)"");
13640 }
13641 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13642 PyObject *resultobj;
13643 wxString *arg1 = 0 ;
13644 wxString *arg2 = 0 ;
13645 wxString *arg3 = 0 ;
13646 wxString *arg4 = 0 ;
13647 wxFileTypeInfo *result;
13648 bool temp1 = false ;
13649 bool temp2 = false ;
13650 bool temp3 = false ;
13651 bool temp4 = false ;
13652 PyObject * obj0 = 0 ;
13653 PyObject * obj1 = 0 ;
13654 PyObject * obj2 = 0 ;
13655 PyObject * obj3 = 0 ;
13656 char *kwnames[] = {
13657 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13658 };
13659
13660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13661 {
13662 arg1 = wxString_in_helper(obj0);
13663 if (arg1 == NULL) SWIG_fail;
13664 temp1 = true;
13665 }
13666 {
13667 arg2 = wxString_in_helper(obj1);
13668 if (arg2 == NULL) SWIG_fail;
13669 temp2 = true;
13670 }
13671 {
13672 arg3 = wxString_in_helper(obj2);
13673 if (arg3 == NULL) SWIG_fail;
13674 temp3 = true;
13675 }
13676 {
13677 arg4 = wxString_in_helper(obj3);
13678 if (arg4 == NULL) SWIG_fail;
13679 temp4 = true;
13680 }
13681 {
13682 PyThreadState* __tstate = wxPyBeginAllowThreads();
13683 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13684
13685 wxPyEndAllowThreads(__tstate);
13686 if (PyErr_Occurred()) SWIG_fail;
13687 }
13688 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13689 {
13690 if (temp1)
13691 delete arg1;
13692 }
13693 {
13694 if (temp2)
13695 delete arg2;
13696 }
13697 {
13698 if (temp3)
13699 delete arg3;
13700 }
13701 {
13702 if (temp4)
13703 delete arg4;
13704 }
13705 return resultobj;
13706 fail:
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 {
13712 if (temp2)
13713 delete arg2;
13714 }
13715 {
13716 if (temp3)
13717 delete arg3;
13718 }
13719 {
13720 if (temp4)
13721 delete arg4;
13722 }
13723 return NULL;
13724 }
13725
13726
13727 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13728 PyObject *resultobj;
13729 wxArrayString *arg1 = 0 ;
13730 wxFileTypeInfo *result;
13731 bool temp1 = false ;
13732 PyObject * obj0 = 0 ;
13733 char *kwnames[] = {
13734 (char *) "sArray", NULL
13735 };
13736
13737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13738 {
13739 if (! PySequence_Check(obj0)) {
13740 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13741 SWIG_fail;
13742 }
13743 arg1 = new wxArrayString;
13744 temp1 = true;
13745 int i, len=PySequence_Length(obj0);
13746 for (i=0; i<len; i++) {
13747 PyObject* item = PySequence_GetItem(obj0, i);
13748 #if wxUSE_UNICODE
13749 PyObject* str = PyObject_Unicode(item);
13750 #else
13751 PyObject* str = PyObject_Str(item);
13752 #endif
13753 if (PyErr_Occurred()) SWIG_fail;
13754 arg1->Add(Py2wxString(str));
13755 Py_DECREF(item);
13756 Py_DECREF(str);
13757 }
13758 }
13759 {
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13762
13763 wxPyEndAllowThreads(__tstate);
13764 if (PyErr_Occurred()) SWIG_fail;
13765 }
13766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13767 {
13768 if (temp1) delete arg1;
13769 }
13770 return resultobj;
13771 fail:
13772 {
13773 if (temp1) delete arg1;
13774 }
13775 return NULL;
13776 }
13777
13778
13779 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13780 PyObject *resultobj;
13781 wxFileTypeInfo *result;
13782 char *kwnames[] = {
13783 NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13787 {
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13790
13791 wxPyEndAllowThreads(__tstate);
13792 if (PyErr_Occurred()) SWIG_fail;
13793 }
13794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13795 return resultobj;
13796 fail:
13797 return NULL;
13798 }
13799
13800
13801 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj;
13803 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13804 bool result;
13805 PyObject * obj0 = 0 ;
13806 char *kwnames[] = {
13807 (char *) "self", NULL
13808 };
13809
13810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13812 if (SWIG_arg_fail(1)) SWIG_fail;
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 {
13821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13822 }
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj;
13831 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13832 wxString *arg2 = 0 ;
13833 int arg3 = (int) 0 ;
13834 bool temp2 = false ;
13835 PyObject * obj0 = 0 ;
13836 PyObject * obj1 = 0 ;
13837 PyObject * obj2 = 0 ;
13838 char *kwnames[] = {
13839 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13840 };
13841
13842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13844 if (SWIG_arg_fail(1)) SWIG_fail;
13845 {
13846 arg2 = wxString_in_helper(obj1);
13847 if (arg2 == NULL) SWIG_fail;
13848 temp2 = true;
13849 }
13850 if (obj2) {
13851 {
13852 arg3 = (int)(SWIG_As_int(obj2));
13853 if (SWIG_arg_fail(3)) SWIG_fail;
13854 }
13855 }
13856 {
13857 PyThreadState* __tstate = wxPyBeginAllowThreads();
13858 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13859
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 Py_INCREF(Py_None); resultobj = Py_None;
13864 {
13865 if (temp2)
13866 delete arg2;
13867 }
13868 return resultobj;
13869 fail:
13870 {
13871 if (temp2)
13872 delete arg2;
13873 }
13874 return NULL;
13875 }
13876
13877
13878 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj;
13880 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13881 wxString *arg2 = 0 ;
13882 bool temp2 = false ;
13883 PyObject * obj0 = 0 ;
13884 PyObject * obj1 = 0 ;
13885 char *kwnames[] = {
13886 (char *) "self",(char *) "shortDesc", NULL
13887 };
13888
13889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13891 if (SWIG_arg_fail(1)) SWIG_fail;
13892 {
13893 arg2 = wxString_in_helper(obj1);
13894 if (arg2 == NULL) SWIG_fail;
13895 temp2 = true;
13896 }
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 (arg1)->SetShortDesc((wxString const &)*arg2);
13900
13901 wxPyEndAllowThreads(__tstate);
13902 if (PyErr_Occurred()) SWIG_fail;
13903 }
13904 Py_INCREF(Py_None); resultobj = Py_None;
13905 {
13906 if (temp2)
13907 delete arg2;
13908 }
13909 return resultobj;
13910 fail:
13911 {
13912 if (temp2)
13913 delete arg2;
13914 }
13915 return NULL;
13916 }
13917
13918
13919 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj;
13921 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13922 wxString *result;
13923 PyObject * obj0 = 0 ;
13924 char *kwnames[] = {
13925 (char *) "self", NULL
13926 };
13927
13928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(1)) SWIG_fail;
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 {
13934 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13935 result = (wxString *) &_result_ref;
13936 }
13937
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 {
13942 #if wxUSE_UNICODE
13943 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13944 #else
13945 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13946 #endif
13947 }
13948 return resultobj;
13949 fail:
13950 return NULL;
13951 }
13952
13953
13954 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13955 PyObject *resultobj;
13956 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13957 wxString *result;
13958 PyObject * obj0 = 0 ;
13959 char *kwnames[] = {
13960 (char *) "self", NULL
13961 };
13962
13963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13965 if (SWIG_arg_fail(1)) SWIG_fail;
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 {
13969 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13970 result = (wxString *) &_result_ref;
13971 }
13972
13973 wxPyEndAllowThreads(__tstate);
13974 if (PyErr_Occurred()) SWIG_fail;
13975 }
13976 {
13977 #if wxUSE_UNICODE
13978 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13979 #else
13980 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13981 #endif
13982 }
13983 return resultobj;
13984 fail:
13985 return NULL;
13986 }
13987
13988
13989 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13990 PyObject *resultobj;
13991 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13992 wxString *result;
13993 PyObject * obj0 = 0 ;
13994 char *kwnames[] = {
13995 (char *) "self", NULL
13996 };
13997
13998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14000 if (SWIG_arg_fail(1)) SWIG_fail;
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 {
14004 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14005 result = (wxString *) &_result_ref;
14006 }
14007
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 {
14012 #if wxUSE_UNICODE
14013 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14014 #else
14015 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14016 #endif
14017 }
14018 return resultobj;
14019 fail:
14020 return NULL;
14021 }
14022
14023
14024 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14025 PyObject *resultobj;
14026 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14027 wxString *result;
14028 PyObject * obj0 = 0 ;
14029 char *kwnames[] = {
14030 (char *) "self", NULL
14031 };
14032
14033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14035 if (SWIG_arg_fail(1)) SWIG_fail;
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 {
14039 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14040 result = (wxString *) &_result_ref;
14041 }
14042
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 {
14047 #if wxUSE_UNICODE
14048 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14049 #else
14050 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14051 #endif
14052 }
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14060 PyObject *resultobj;
14061 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14062 wxString *result;
14063 PyObject * obj0 = 0 ;
14064 char *kwnames[] = {
14065 (char *) "self", NULL
14066 };
14067
14068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14070 if (SWIG_arg_fail(1)) SWIG_fail;
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 {
14074 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14075 result = (wxString *) &_result_ref;
14076 }
14077
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 {
14082 #if wxUSE_UNICODE
14083 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14084 #else
14085 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14086 #endif
14087 }
14088 return resultobj;
14089 fail:
14090 return NULL;
14091 }
14092
14093
14094 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14095 PyObject *resultobj;
14096 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14097 wxArrayString *result;
14098 PyObject * obj0 = 0 ;
14099 char *kwnames[] = {
14100 (char *) "self", NULL
14101 };
14102
14103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14105 if (SWIG_arg_fail(1)) SWIG_fail;
14106 {
14107 PyThreadState* __tstate = wxPyBeginAllowThreads();
14108 {
14109 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14110 result = (wxArrayString *) &_result_ref;
14111 }
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = wxArrayString2PyList_helper(*result);
14118 }
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj;
14127 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14128 int result;
14129 PyObject * obj0 = 0 ;
14130 char *kwnames[] = {
14131 (char *) "self", NULL
14132 };
14133
14134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14136 if (SWIG_arg_fail(1)) SWIG_fail;
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14140
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 resultobj = SWIG_From_int((int)(result));
14146 }
14147 return resultobj;
14148 fail:
14149 return NULL;
14150 }
14151
14152
14153 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14154 PyObject *resultobj;
14155 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14156 wxString *result;
14157 PyObject * obj0 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 {
14168 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14169 result = (wxString *) &_result_ref;
14170 }
14171
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 {
14176 #if wxUSE_UNICODE
14177 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14178 #else
14179 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14180 #endif
14181 }
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj;
14190 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14191 int result;
14192 PyObject * obj0 = 0 ;
14193 char *kwnames[] = {
14194 (char *) "self", NULL
14195 };
14196
14197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(1)) SWIG_fail;
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14203
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 resultobj = SWIG_From_int((int)(result));
14209 }
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14217 PyObject *obj;
14218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14219 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14220 Py_INCREF(obj);
14221 return Py_BuildValue((char *)"");
14222 }
14223 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj;
14225 wxFileTypeInfo *arg1 = 0 ;
14226 wxFileType *result;
14227 PyObject * obj0 = 0 ;
14228 char *kwnames[] = {
14229 (char *) "ftInfo", NULL
14230 };
14231
14232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14233 {
14234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14235 if (SWIG_arg_fail(1)) SWIG_fail;
14236 if (arg1 == NULL) {
14237 SWIG_null_ref("wxFileTypeInfo");
14238 }
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14244
14245 wxPyEndAllowThreads(__tstate);
14246 if (PyErr_Occurred()) SWIG_fail;
14247 }
14248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj;
14257 wxFileType *arg1 = (wxFileType *) 0 ;
14258 PyObject * obj0 = 0 ;
14259 char *kwnames[] = {
14260 (char *) "self", NULL
14261 };
14262
14263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14265 if (SWIG_arg_fail(1)) SWIG_fail;
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 delete arg1;
14269
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 Py_INCREF(Py_None); resultobj = Py_None;
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj;
14282 wxFileType *arg1 = (wxFileType *) 0 ;
14283 PyObject *result;
14284 PyObject * obj0 = 0 ;
14285 char *kwnames[] = {
14286 (char *) "self", NULL
14287 };
14288
14289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14291 if (SWIG_arg_fail(1)) SWIG_fail;
14292 {
14293 PyThreadState* __tstate = wxPyBeginAllowThreads();
14294 result = (PyObject *)wxFileType_GetMimeType(arg1);
14295
14296 wxPyEndAllowThreads(__tstate);
14297 if (PyErr_Occurred()) SWIG_fail;
14298 }
14299 resultobj = result;
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14307 PyObject *resultobj;
14308 wxFileType *arg1 = (wxFileType *) 0 ;
14309 PyObject *result;
14310 PyObject * obj0 = 0 ;
14311 char *kwnames[] = {
14312 (char *) "self", NULL
14313 };
14314
14315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14317 if (SWIG_arg_fail(1)) SWIG_fail;
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 resultobj = result;
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj;
14334 wxFileType *arg1 = (wxFileType *) 0 ;
14335 PyObject *result;
14336 PyObject * obj0 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (PyObject *)wxFileType_GetExtensions(arg1);
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = result;
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxFileType *arg1 = (wxFileType *) 0 ;
14361 wxIcon *result;
14362 PyObject * obj0 = 0 ;
14363 char *kwnames[] = {
14364 (char *) "self", NULL
14365 };
14366
14367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14369 if (SWIG_arg_fail(1)) SWIG_fail;
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 result = (wxIcon *)wxFileType_GetIcon(arg1);
14373
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14378 return resultobj;
14379 fail:
14380 return NULL;
14381 }
14382
14383
14384 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14385 PyObject *resultobj;
14386 wxFileType *arg1 = (wxFileType *) 0 ;
14387 PyObject *result;
14388 PyObject * obj0 = 0 ;
14389 char *kwnames[] = {
14390 (char *) "self", NULL
14391 };
14392
14393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14395 if (SWIG_arg_fail(1)) SWIG_fail;
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14399
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 resultobj = result;
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj;
14412 wxFileType *arg1 = (wxFileType *) 0 ;
14413 PyObject *result;
14414 PyObject * obj0 = 0 ;
14415 char *kwnames[] = {
14416 (char *) "self", NULL
14417 };
14418
14419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14421 if (SWIG_arg_fail(1)) SWIG_fail;
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = (PyObject *)wxFileType_GetDescription(arg1);
14425
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 resultobj = result;
14430 return resultobj;
14431 fail:
14432 return NULL;
14433 }
14434
14435
14436 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14437 PyObject *resultobj;
14438 wxFileType *arg1 = (wxFileType *) 0 ;
14439 wxString *arg2 = 0 ;
14440 wxString const &arg3_defvalue = wxPyEmptyString ;
14441 wxString *arg3 = (wxString *) &arg3_defvalue ;
14442 PyObject *result;
14443 bool temp2 = false ;
14444 bool temp3 = false ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 PyObject * obj2 = 0 ;
14448 char *kwnames[] = {
14449 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14454 if (SWIG_arg_fail(1)) SWIG_fail;
14455 {
14456 arg2 = wxString_in_helper(obj1);
14457 if (arg2 == NULL) SWIG_fail;
14458 temp2 = true;
14459 }
14460 if (obj2) {
14461 {
14462 arg3 = wxString_in_helper(obj2);
14463 if (arg3 == NULL) SWIG_fail;
14464 temp3 = true;
14465 }
14466 }
14467 {
14468 PyThreadState* __tstate = wxPyBeginAllowThreads();
14469 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14470
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = result;
14475 {
14476 if (temp2)
14477 delete arg2;
14478 }
14479 {
14480 if (temp3)
14481 delete arg3;
14482 }
14483 return resultobj;
14484 fail:
14485 {
14486 if (temp2)
14487 delete arg2;
14488 }
14489 {
14490 if (temp3)
14491 delete arg3;
14492 }
14493 return NULL;
14494 }
14495
14496
14497 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj;
14499 wxFileType *arg1 = (wxFileType *) 0 ;
14500 wxString *arg2 = 0 ;
14501 wxString const &arg3_defvalue = wxPyEmptyString ;
14502 wxString *arg3 = (wxString *) &arg3_defvalue ;
14503 PyObject *result;
14504 bool temp2 = false ;
14505 bool temp3 = false ;
14506 PyObject * obj0 = 0 ;
14507 PyObject * obj1 = 0 ;
14508 PyObject * obj2 = 0 ;
14509 char *kwnames[] = {
14510 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14511 };
14512
14513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14515 if (SWIG_arg_fail(1)) SWIG_fail;
14516 {
14517 arg2 = wxString_in_helper(obj1);
14518 if (arg2 == NULL) SWIG_fail;
14519 temp2 = true;
14520 }
14521 if (obj2) {
14522 {
14523 arg3 = wxString_in_helper(obj2);
14524 if (arg3 == NULL) SWIG_fail;
14525 temp3 = true;
14526 }
14527 }
14528 {
14529 PyThreadState* __tstate = wxPyBeginAllowThreads();
14530 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14531
14532 wxPyEndAllowThreads(__tstate);
14533 if (PyErr_Occurred()) SWIG_fail;
14534 }
14535 resultobj = result;
14536 {
14537 if (temp2)
14538 delete arg2;
14539 }
14540 {
14541 if (temp3)
14542 delete arg3;
14543 }
14544 return resultobj;
14545 fail:
14546 {
14547 if (temp2)
14548 delete arg2;
14549 }
14550 {
14551 if (temp3)
14552 delete arg3;
14553 }
14554 return NULL;
14555 }
14556
14557
14558 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14559 PyObject *resultobj;
14560 wxFileType *arg1 = (wxFileType *) 0 ;
14561 wxString *arg2 = 0 ;
14562 wxString const &arg3_defvalue = wxPyEmptyString ;
14563 wxString *arg3 = (wxString *) &arg3_defvalue ;
14564 PyObject *result;
14565 bool temp2 = false ;
14566 bool temp3 = false ;
14567 PyObject * obj0 = 0 ;
14568 PyObject * obj1 = 0 ;
14569 PyObject * obj2 = 0 ;
14570 char *kwnames[] = {
14571 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14572 };
14573
14574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14576 if (SWIG_arg_fail(1)) SWIG_fail;
14577 {
14578 arg2 = wxString_in_helper(obj1);
14579 if (arg2 == NULL) SWIG_fail;
14580 temp2 = true;
14581 }
14582 if (obj2) {
14583 {
14584 arg3 = wxString_in_helper(obj2);
14585 if (arg3 == NULL) SWIG_fail;
14586 temp3 = true;
14587 }
14588 }
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14592
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = result;
14597 {
14598 if (temp2)
14599 delete arg2;
14600 }
14601 {
14602 if (temp3)
14603 delete arg3;
14604 }
14605 return resultobj;
14606 fail:
14607 {
14608 if (temp2)
14609 delete arg2;
14610 }
14611 {
14612 if (temp3)
14613 delete arg3;
14614 }
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxFileType *arg1 = (wxFileType *) 0 ;
14622 wxString *arg2 = 0 ;
14623 wxString *arg3 = 0 ;
14624 bool arg4 = (bool) true ;
14625 bool result;
14626 bool temp2 = false ;
14627 bool temp3 = false ;
14628 PyObject * obj0 = 0 ;
14629 PyObject * obj1 = 0 ;
14630 PyObject * obj2 = 0 ;
14631 PyObject * obj3 = 0 ;
14632 char *kwnames[] = {
14633 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14634 };
14635
14636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14638 if (SWIG_arg_fail(1)) SWIG_fail;
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 {
14645 arg3 = wxString_in_helper(obj2);
14646 if (arg3 == NULL) SWIG_fail;
14647 temp3 = true;
14648 }
14649 if (obj3) {
14650 {
14651 arg4 = (bool)(SWIG_As_bool(obj3));
14652 if (SWIG_arg_fail(4)) SWIG_fail;
14653 }
14654 }
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14658
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 {
14663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14664 }
14665 {
14666 if (temp2)
14667 delete arg2;
14668 }
14669 {
14670 if (temp3)
14671 delete arg3;
14672 }
14673 return resultobj;
14674 fail:
14675 {
14676 if (temp2)
14677 delete arg2;
14678 }
14679 {
14680 if (temp3)
14681 delete arg3;
14682 }
14683 return NULL;
14684 }
14685
14686
14687 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj;
14689 wxFileType *arg1 = (wxFileType *) 0 ;
14690 wxString const &arg2_defvalue = wxPyEmptyString ;
14691 wxString *arg2 = (wxString *) &arg2_defvalue ;
14692 int arg3 = (int) 0 ;
14693 bool result;
14694 bool temp2 = false ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 PyObject * obj2 = 0 ;
14698 char *kwnames[] = {
14699 (char *) "self",(char *) "cmd",(char *) "index", NULL
14700 };
14701
14702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14704 if (SWIG_arg_fail(1)) SWIG_fail;
14705 if (obj1) {
14706 {
14707 arg2 = wxString_in_helper(obj1);
14708 if (arg2 == NULL) SWIG_fail;
14709 temp2 = true;
14710 }
14711 }
14712 if (obj2) {
14713 {
14714 arg3 = (int)(SWIG_As_int(obj2));
14715 if (SWIG_arg_fail(3)) SWIG_fail;
14716 }
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14721
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 {
14726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14727 }
14728 {
14729 if (temp2)
14730 delete arg2;
14731 }
14732 return resultobj;
14733 fail:
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 return NULL;
14739 }
14740
14741
14742 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj;
14744 wxFileType *arg1 = (wxFileType *) 0 ;
14745 bool result;
14746 PyObject * obj0 = 0 ;
14747 char *kwnames[] = {
14748 (char *) "self", NULL
14749 };
14750
14751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14753 if (SWIG_arg_fail(1)) SWIG_fail;
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 result = (bool)(arg1)->Unassociate();
14757
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 {
14762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14763 }
14764 return resultobj;
14765 fail:
14766 return NULL;
14767 }
14768
14769
14770 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxString *arg1 = 0 ;
14773 wxString *arg2 = 0 ;
14774 wxString const &arg3_defvalue = wxPyEmptyString ;
14775 wxString *arg3 = (wxString *) &arg3_defvalue ;
14776 wxString result;
14777 bool temp1 = false ;
14778 bool temp2 = false ;
14779 bool temp3 = false ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 PyObject * obj2 = 0 ;
14783 char *kwnames[] = {
14784 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14785 };
14786
14787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14788 {
14789 arg1 = wxString_in_helper(obj0);
14790 if (arg1 == NULL) SWIG_fail;
14791 temp1 = true;
14792 }
14793 {
14794 arg2 = wxString_in_helper(obj1);
14795 if (arg2 == NULL) SWIG_fail;
14796 temp2 = true;
14797 }
14798 if (obj2) {
14799 {
14800 arg3 = wxString_in_helper(obj2);
14801 if (arg3 == NULL) SWIG_fail;
14802 temp3 = true;
14803 }
14804 }
14805 {
14806 PyThreadState* __tstate = wxPyBeginAllowThreads();
14807 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14808
14809 wxPyEndAllowThreads(__tstate);
14810 if (PyErr_Occurred()) SWIG_fail;
14811 }
14812 {
14813 #if wxUSE_UNICODE
14814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14815 #else
14816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14817 #endif
14818 }
14819 {
14820 if (temp1)
14821 delete arg1;
14822 }
14823 {
14824 if (temp2)
14825 delete arg2;
14826 }
14827 {
14828 if (temp3)
14829 delete arg3;
14830 }
14831 return resultobj;
14832 fail:
14833 {
14834 if (temp1)
14835 delete arg1;
14836 }
14837 {
14838 if (temp2)
14839 delete arg2;
14840 }
14841 {
14842 if (temp3)
14843 delete arg3;
14844 }
14845 return NULL;
14846 }
14847
14848
14849 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14850 PyObject *obj;
14851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14852 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14853 Py_INCREF(obj);
14854 return Py_BuildValue((char *)"");
14855 }
14856 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14857 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14858 return 1;
14859 }
14860
14861
14862 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14863 PyObject *pyobj;
14864
14865 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14866 return pyobj;
14867 }
14868
14869
14870 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14871 PyObject *resultobj;
14872 wxString *arg1 = 0 ;
14873 wxString *arg2 = 0 ;
14874 bool result;
14875 bool temp1 = false ;
14876 bool temp2 = false ;
14877 PyObject * obj0 = 0 ;
14878 PyObject * obj1 = 0 ;
14879 char *kwnames[] = {
14880 (char *) "mimeType",(char *) "wildcard", NULL
14881 };
14882
14883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14884 {
14885 arg1 = wxString_in_helper(obj0);
14886 if (arg1 == NULL) SWIG_fail;
14887 temp1 = true;
14888 }
14889 {
14890 arg2 = wxString_in_helper(obj1);
14891 if (arg2 == NULL) SWIG_fail;
14892 temp2 = true;
14893 }
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14897
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 {
14902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14903 }
14904 {
14905 if (temp1)
14906 delete arg1;
14907 }
14908 {
14909 if (temp2)
14910 delete arg2;
14911 }
14912 return resultobj;
14913 fail:
14914 {
14915 if (temp1)
14916 delete arg1;
14917 }
14918 {
14919 if (temp2)
14920 delete arg2;
14921 }
14922 return NULL;
14923 }
14924
14925
14926 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14927 PyObject *resultobj;
14928 wxMimeTypesManager *result;
14929 char *kwnames[] = {
14930 NULL
14931 };
14932
14933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14937
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14949 PyObject *resultobj;
14950 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14951 int arg2 = (int) wxMAILCAP_ALL ;
14952 wxString const &arg3_defvalue = wxPyEmptyString ;
14953 wxString *arg3 = (wxString *) &arg3_defvalue ;
14954 bool temp3 = false ;
14955 PyObject * obj0 = 0 ;
14956 PyObject * obj1 = 0 ;
14957 PyObject * obj2 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14964 if (SWIG_arg_fail(1)) SWIG_fail;
14965 if (obj1) {
14966 {
14967 arg2 = (int)(SWIG_As_int(obj1));
14968 if (SWIG_arg_fail(2)) SWIG_fail;
14969 }
14970 }
14971 if (obj2) {
14972 {
14973 arg3 = wxString_in_helper(obj2);
14974 if (arg3 == NULL) SWIG_fail;
14975 temp3 = true;
14976 }
14977 }
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14981
14982 wxPyEndAllowThreads(__tstate);
14983 if (PyErr_Occurred()) SWIG_fail;
14984 }
14985 Py_INCREF(Py_None); resultobj = Py_None;
14986 {
14987 if (temp3)
14988 delete arg3;
14989 }
14990 return resultobj;
14991 fail:
14992 {
14993 if (temp3)
14994 delete arg3;
14995 }
14996 return NULL;
14997 }
14998
14999
15000 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15001 PyObject *resultobj;
15002 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15003 PyObject * obj0 = 0 ;
15004 char *kwnames[] = {
15005 (char *) "self", NULL
15006 };
15007
15008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15010 if (SWIG_arg_fail(1)) SWIG_fail;
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 (arg1)->ClearData();
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 Py_INCREF(Py_None); resultobj = Py_None;
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15026 PyObject *resultobj;
15027 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15028 wxString *arg2 = 0 ;
15029 wxFileType *result;
15030 bool temp2 = false ;
15031 PyObject * obj0 = 0 ;
15032 PyObject * obj1 = 0 ;
15033 char *kwnames[] = {
15034 (char *) "self",(char *) "ext", NULL
15035 };
15036
15037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15039 if (SWIG_arg_fail(1)) SWIG_fail;
15040 {
15041 arg2 = wxString_in_helper(obj1);
15042 if (arg2 == NULL) SWIG_fail;
15043 temp2 = true;
15044 }
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15048
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15053 {
15054 if (temp2)
15055 delete arg2;
15056 }
15057 return resultobj;
15058 fail:
15059 {
15060 if (temp2)
15061 delete arg2;
15062 }
15063 return NULL;
15064 }
15065
15066
15067 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15068 PyObject *resultobj;
15069 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15070 wxString *arg2 = 0 ;
15071 wxFileType *result;
15072 bool temp2 = false ;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 char *kwnames[] = {
15076 (char *) "self",(char *) "mimeType", NULL
15077 };
15078
15079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15081 if (SWIG_arg_fail(1)) SWIG_fail;
15082 {
15083 arg2 = wxString_in_helper(obj1);
15084 if (arg2 == NULL) SWIG_fail;
15085 temp2 = true;
15086 }
15087 {
15088 PyThreadState* __tstate = wxPyBeginAllowThreads();
15089 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15090
15091 wxPyEndAllowThreads(__tstate);
15092 if (PyErr_Occurred()) SWIG_fail;
15093 }
15094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15095 {
15096 if (temp2)
15097 delete arg2;
15098 }
15099 return resultobj;
15100 fail:
15101 {
15102 if (temp2)
15103 delete arg2;
15104 }
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15112 wxString *arg2 = 0 ;
15113 bool arg3 = (bool) false ;
15114 bool result;
15115 bool temp2 = false ;
15116 PyObject * obj0 = 0 ;
15117 PyObject * obj1 = 0 ;
15118 PyObject * obj2 = 0 ;
15119 char *kwnames[] = {
15120 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15121 };
15122
15123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15125 if (SWIG_arg_fail(1)) SWIG_fail;
15126 {
15127 arg2 = wxString_in_helper(obj1);
15128 if (arg2 == NULL) SWIG_fail;
15129 temp2 = true;
15130 }
15131 if (obj2) {
15132 {
15133 arg3 = (bool)(SWIG_As_bool(obj2));
15134 if (SWIG_arg_fail(3)) SWIG_fail;
15135 }
15136 }
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15140
15141 wxPyEndAllowThreads(__tstate);
15142 if (PyErr_Occurred()) SWIG_fail;
15143 }
15144 {
15145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15146 }
15147 {
15148 if (temp2)
15149 delete arg2;
15150 }
15151 return resultobj;
15152 fail:
15153 {
15154 if (temp2)
15155 delete arg2;
15156 }
15157 return NULL;
15158 }
15159
15160
15161 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj;
15163 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15164 wxString *arg2 = 0 ;
15165 bool result;
15166 bool temp2 = false ;
15167 PyObject * obj0 = 0 ;
15168 PyObject * obj1 = 0 ;
15169 char *kwnames[] = {
15170 (char *) "self",(char *) "filename", NULL
15171 };
15172
15173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15175 if (SWIG_arg_fail(1)) SWIG_fail;
15176 {
15177 arg2 = wxString_in_helper(obj1);
15178 if (arg2 == NULL) SWIG_fail;
15179 temp2 = true;
15180 }
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15184
15185 wxPyEndAllowThreads(__tstate);
15186 if (PyErr_Occurred()) SWIG_fail;
15187 }
15188 {
15189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15190 }
15191 {
15192 if (temp2)
15193 delete arg2;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (temp2)
15199 delete arg2;
15200 }
15201 return NULL;
15202 }
15203
15204
15205 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj;
15207 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15208 PyObject *result;
15209 PyObject * obj0 = 0 ;
15210 char *kwnames[] = {
15211 (char *) "self", NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15216 if (SWIG_arg_fail(1)) SWIG_fail;
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15220
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = result;
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj;
15233 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15234 wxFileTypeInfo *arg2 = 0 ;
15235 PyObject * obj0 = 0 ;
15236 PyObject * obj1 = 0 ;
15237 char *kwnames[] = {
15238 (char *) "self",(char *) "ft", NULL
15239 };
15240
15241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 {
15245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15246 if (SWIG_arg_fail(2)) SWIG_fail;
15247 if (arg2 == NULL) {
15248 SWIG_null_ref("wxFileTypeInfo");
15249 }
15250 if (SWIG_arg_fail(2)) SWIG_fail;
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15255
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 Py_INCREF(Py_None); resultobj = Py_None;
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15267 PyObject *resultobj;
15268 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15269 wxFileTypeInfo *arg2 = 0 ;
15270 wxFileType *result;
15271 PyObject * obj0 = 0 ;
15272 PyObject * obj1 = 0 ;
15273 char *kwnames[] = {
15274 (char *) "self",(char *) "ftInfo", NULL
15275 };
15276
15277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15279 if (SWIG_arg_fail(1)) SWIG_fail;
15280 {
15281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15282 if (SWIG_arg_fail(2)) SWIG_fail;
15283 if (arg2 == NULL) {
15284 SWIG_null_ref("wxFileTypeInfo");
15285 }
15286 if (SWIG_arg_fail(2)) SWIG_fail;
15287 }
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15291
15292 wxPyEndAllowThreads(__tstate);
15293 if (PyErr_Occurred()) SWIG_fail;
15294 }
15295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15296 return resultobj;
15297 fail:
15298 return NULL;
15299 }
15300
15301
15302 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15303 PyObject *resultobj;
15304 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15305 wxFileType *arg2 = (wxFileType *) 0 ;
15306 bool result;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char *kwnames[] = {
15310 (char *) "self",(char *) "ft", NULL
15311 };
15312
15313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15315 if (SWIG_arg_fail(1)) SWIG_fail;
15316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15317 if (SWIG_arg_fail(2)) SWIG_fail;
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (bool)(arg1)->Unassociate(arg2);
15321
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15327 }
15328 return resultobj;
15329 fail:
15330 return NULL;
15331 }
15332
15333
15334 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15335 PyObject *resultobj;
15336 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15337 PyObject * obj0 = 0 ;
15338 char *kwnames[] = {
15339 (char *) "self", NULL
15340 };
15341
15342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15344 if (SWIG_arg_fail(1)) SWIG_fail;
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 delete arg1;
15348
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 Py_INCREF(Py_None); resultobj = Py_None;
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15360 PyObject *obj;
15361 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15362 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15363 Py_INCREF(obj);
15364 return Py_BuildValue((char *)"");
15365 }
15366 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15367 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15368 return 1;
15369 }
15370
15371
15372 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15373 PyObject *pyobj;
15374
15375 {
15376 #if wxUSE_UNICODE
15377 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15378 #else
15379 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15380 #endif
15381 }
15382 return pyobj;
15383 }
15384
15385
15386 static int _wrap_ART_MENU_set(PyObject *) {
15387 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15388 return 1;
15389 }
15390
15391
15392 static PyObject *_wrap_ART_MENU_get(void) {
15393 PyObject *pyobj;
15394
15395 {
15396 #if wxUSE_UNICODE
15397 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15398 #else
15399 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15400 #endif
15401 }
15402 return pyobj;
15403 }
15404
15405
15406 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15407 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15408 return 1;
15409 }
15410
15411
15412 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15413 PyObject *pyobj;
15414
15415 {
15416 #if wxUSE_UNICODE
15417 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15418 #else
15419 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15420 #endif
15421 }
15422 return pyobj;
15423 }
15424
15425
15426 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15427 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15428 return 1;
15429 }
15430
15431
15432 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15433 PyObject *pyobj;
15434
15435 {
15436 #if wxUSE_UNICODE
15437 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15438 #else
15439 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15440 #endif
15441 }
15442 return pyobj;
15443 }
15444
15445
15446 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15447 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15448 return 1;
15449 }
15450
15451
15452 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15453 PyObject *pyobj;
15454
15455 {
15456 #if wxUSE_UNICODE
15457 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15458 #else
15459 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15460 #endif
15461 }
15462 return pyobj;
15463 }
15464
15465
15466 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15467 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15468 return 1;
15469 }
15470
15471
15472 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15473 PyObject *pyobj;
15474
15475 {
15476 #if wxUSE_UNICODE
15477 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15478 #else
15479 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15480 #endif
15481 }
15482 return pyobj;
15483 }
15484
15485
15486 static int _wrap_ART_BUTTON_set(PyObject *) {
15487 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15488 return 1;
15489 }
15490
15491
15492 static PyObject *_wrap_ART_BUTTON_get(void) {
15493 PyObject *pyobj;
15494
15495 {
15496 #if wxUSE_UNICODE
15497 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15498 #else
15499 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15500 #endif
15501 }
15502 return pyobj;
15503 }
15504
15505
15506 static int _wrap_ART_OTHER_set(PyObject *) {
15507 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15508 return 1;
15509 }
15510
15511
15512 static PyObject *_wrap_ART_OTHER_get(void) {
15513 PyObject *pyobj;
15514
15515 {
15516 #if wxUSE_UNICODE
15517 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15518 #else
15519 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15520 #endif
15521 }
15522 return pyobj;
15523 }
15524
15525
15526 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15527 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15528 return 1;
15529 }
15530
15531
15532 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15533 PyObject *pyobj;
15534
15535 {
15536 #if wxUSE_UNICODE
15537 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15538 #else
15539 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15540 #endif
15541 }
15542 return pyobj;
15543 }
15544
15545
15546 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15547 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15548 return 1;
15549 }
15550
15551
15552 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15553 PyObject *pyobj;
15554
15555 {
15556 #if wxUSE_UNICODE
15557 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15558 #else
15559 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15560 #endif
15561 }
15562 return pyobj;
15563 }
15564
15565
15566 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15567 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15568 return 1;
15569 }
15570
15571
15572 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15573 PyObject *pyobj;
15574
15575 {
15576 #if wxUSE_UNICODE
15577 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15578 #else
15579 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15580 #endif
15581 }
15582 return pyobj;
15583 }
15584
15585
15586 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15587 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15588 return 1;
15589 }
15590
15591
15592 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15593 PyObject *pyobj;
15594
15595 {
15596 #if wxUSE_UNICODE
15597 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15598 #else
15599 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15600 #endif
15601 }
15602 return pyobj;
15603 }
15604
15605
15606 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15607 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15608 return 1;
15609 }
15610
15611
15612 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15613 PyObject *pyobj;
15614
15615 {
15616 #if wxUSE_UNICODE
15617 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15618 #else
15619 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15620 #endif
15621 }
15622 return pyobj;
15623 }
15624
15625
15626 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15627 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15628 return 1;
15629 }
15630
15631
15632 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15633 PyObject *pyobj;
15634
15635 {
15636 #if wxUSE_UNICODE
15637 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15638 #else
15639 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15640 #endif
15641 }
15642 return pyobj;
15643 }
15644
15645
15646 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15647 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15648 return 1;
15649 }
15650
15651
15652 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15653 PyObject *pyobj;
15654
15655 {
15656 #if wxUSE_UNICODE
15657 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15658 #else
15659 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15660 #endif
15661 }
15662 return pyobj;
15663 }
15664
15665
15666 static int _wrap_ART_GO_BACK_set(PyObject *) {
15667 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15668 return 1;
15669 }
15670
15671
15672 static PyObject *_wrap_ART_GO_BACK_get(void) {
15673 PyObject *pyobj;
15674
15675 {
15676 #if wxUSE_UNICODE
15677 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15678 #else
15679 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15680 #endif
15681 }
15682 return pyobj;
15683 }
15684
15685
15686 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15687 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15688 return 1;
15689 }
15690
15691
15692 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15693 PyObject *pyobj;
15694
15695 {
15696 #if wxUSE_UNICODE
15697 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15698 #else
15699 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15700 #endif
15701 }
15702 return pyobj;
15703 }
15704
15705
15706 static int _wrap_ART_GO_UP_set(PyObject *) {
15707 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15708 return 1;
15709 }
15710
15711
15712 static PyObject *_wrap_ART_GO_UP_get(void) {
15713 PyObject *pyobj;
15714
15715 {
15716 #if wxUSE_UNICODE
15717 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15718 #else
15719 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15720 #endif
15721 }
15722 return pyobj;
15723 }
15724
15725
15726 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15727 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15728 return 1;
15729 }
15730
15731
15732 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15733 PyObject *pyobj;
15734
15735 {
15736 #if wxUSE_UNICODE
15737 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15738 #else
15739 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15740 #endif
15741 }
15742 return pyobj;
15743 }
15744
15745
15746 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15747 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15748 return 1;
15749 }
15750
15751
15752 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15753 PyObject *pyobj;
15754
15755 {
15756 #if wxUSE_UNICODE
15757 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15758 #else
15759 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15760 #endif
15761 }
15762 return pyobj;
15763 }
15764
15765
15766 static int _wrap_ART_GO_HOME_set(PyObject *) {
15767 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15768 return 1;
15769 }
15770
15771
15772 static PyObject *_wrap_ART_GO_HOME_get(void) {
15773 PyObject *pyobj;
15774
15775 {
15776 #if wxUSE_UNICODE
15777 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15778 #else
15779 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15780 #endif
15781 }
15782 return pyobj;
15783 }
15784
15785
15786 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15787 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15788 return 1;
15789 }
15790
15791
15792 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15793 PyObject *pyobj;
15794
15795 {
15796 #if wxUSE_UNICODE
15797 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15798 #else
15799 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15800 #endif
15801 }
15802 return pyobj;
15803 }
15804
15805
15806 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15807 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15808 return 1;
15809 }
15810
15811
15812 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15813 PyObject *pyobj;
15814
15815 {
15816 #if wxUSE_UNICODE
15817 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15818 #else
15819 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15820 #endif
15821 }
15822 return pyobj;
15823 }
15824
15825
15826 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15827 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15828 return 1;
15829 }
15830
15831
15832 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15833 PyObject *pyobj;
15834
15835 {
15836 #if wxUSE_UNICODE
15837 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15838 #else
15839 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15840 #endif
15841 }
15842 return pyobj;
15843 }
15844
15845
15846 static int _wrap_ART_PRINT_set(PyObject *) {
15847 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15848 return 1;
15849 }
15850
15851
15852 static PyObject *_wrap_ART_PRINT_get(void) {
15853 PyObject *pyobj;
15854
15855 {
15856 #if wxUSE_UNICODE
15857 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15858 #else
15859 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15860 #endif
15861 }
15862 return pyobj;
15863 }
15864
15865
15866 static int _wrap_ART_HELP_set(PyObject *) {
15867 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15868 return 1;
15869 }
15870
15871
15872 static PyObject *_wrap_ART_HELP_get(void) {
15873 PyObject *pyobj;
15874
15875 {
15876 #if wxUSE_UNICODE
15877 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15878 #else
15879 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15880 #endif
15881 }
15882 return pyobj;
15883 }
15884
15885
15886 static int _wrap_ART_TIP_set(PyObject *) {
15887 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15888 return 1;
15889 }
15890
15891
15892 static PyObject *_wrap_ART_TIP_get(void) {
15893 PyObject *pyobj;
15894
15895 {
15896 #if wxUSE_UNICODE
15897 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15898 #else
15899 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15900 #endif
15901 }
15902 return pyobj;
15903 }
15904
15905
15906 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15907 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15908 return 1;
15909 }
15910
15911
15912 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15913 PyObject *pyobj;
15914
15915 {
15916 #if wxUSE_UNICODE
15917 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15918 #else
15919 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15920 #endif
15921 }
15922 return pyobj;
15923 }
15924
15925
15926 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15927 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15928 return 1;
15929 }
15930
15931
15932 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15933 PyObject *pyobj;
15934
15935 {
15936 #if wxUSE_UNICODE
15937 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15938 #else
15939 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15940 #endif
15941 }
15942 return pyobj;
15943 }
15944
15945
15946 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15947 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15948 return 1;
15949 }
15950
15951
15952 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15953 PyObject *pyobj;
15954
15955 {
15956 #if wxUSE_UNICODE
15957 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15958 #else
15959 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15960 #endif
15961 }
15962 return pyobj;
15963 }
15964
15965
15966 static int _wrap_ART_HARDDISK_set(PyObject *) {
15967 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15968 return 1;
15969 }
15970
15971
15972 static PyObject *_wrap_ART_HARDDISK_get(void) {
15973 PyObject *pyobj;
15974
15975 {
15976 #if wxUSE_UNICODE
15977 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15978 #else
15979 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15980 #endif
15981 }
15982 return pyobj;
15983 }
15984
15985
15986 static int _wrap_ART_FLOPPY_set(PyObject *) {
15987 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15988 return 1;
15989 }
15990
15991
15992 static PyObject *_wrap_ART_FLOPPY_get(void) {
15993 PyObject *pyobj;
15994
15995 {
15996 #if wxUSE_UNICODE
15997 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15998 #else
15999 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16000 #endif
16001 }
16002 return pyobj;
16003 }
16004
16005
16006 static int _wrap_ART_CDROM_set(PyObject *) {
16007 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16008 return 1;
16009 }
16010
16011
16012 static PyObject *_wrap_ART_CDROM_get(void) {
16013 PyObject *pyobj;
16014
16015 {
16016 #if wxUSE_UNICODE
16017 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16018 #else
16019 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16020 #endif
16021 }
16022 return pyobj;
16023 }
16024
16025
16026 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16027 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16028 return 1;
16029 }
16030
16031
16032 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16033 PyObject *pyobj;
16034
16035 {
16036 #if wxUSE_UNICODE
16037 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16038 #else
16039 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16040 #endif
16041 }
16042 return pyobj;
16043 }
16044
16045
16046 static int _wrap_ART_FOLDER_set(PyObject *) {
16047 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16048 return 1;
16049 }
16050
16051
16052 static PyObject *_wrap_ART_FOLDER_get(void) {
16053 PyObject *pyobj;
16054
16055 {
16056 #if wxUSE_UNICODE
16057 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16058 #else
16059 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16060 #endif
16061 }
16062 return pyobj;
16063 }
16064
16065
16066 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16067 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16068 return 1;
16069 }
16070
16071
16072 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16073 PyObject *pyobj;
16074
16075 {
16076 #if wxUSE_UNICODE
16077 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16078 #else
16079 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16080 #endif
16081 }
16082 return pyobj;
16083 }
16084
16085
16086 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16087 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16088 return 1;
16089 }
16090
16091
16092 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16093 PyObject *pyobj;
16094
16095 {
16096 #if wxUSE_UNICODE
16097 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16098 #else
16099 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16100 #endif
16101 }
16102 return pyobj;
16103 }
16104
16105
16106 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16107 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16108 return 1;
16109 }
16110
16111
16112 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16113 PyObject *pyobj;
16114
16115 {
16116 #if wxUSE_UNICODE
16117 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16118 #else
16119 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16120 #endif
16121 }
16122 return pyobj;
16123 }
16124
16125
16126 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16127 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16128 return 1;
16129 }
16130
16131
16132 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16133 PyObject *pyobj;
16134
16135 {
16136 #if wxUSE_UNICODE
16137 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16138 #else
16139 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16140 #endif
16141 }
16142 return pyobj;
16143 }
16144
16145
16146 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16147 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16148 return 1;
16149 }
16150
16151
16152 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16153 PyObject *pyobj;
16154
16155 {
16156 #if wxUSE_UNICODE
16157 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16158 #else
16159 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16160 #endif
16161 }
16162 return pyobj;
16163 }
16164
16165
16166 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16167 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16168 return 1;
16169 }
16170
16171
16172 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16173 PyObject *pyobj;
16174
16175 {
16176 #if wxUSE_UNICODE
16177 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16178 #else
16179 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16180 #endif
16181 }
16182 return pyobj;
16183 }
16184
16185
16186 static int _wrap_ART_ERROR_set(PyObject *) {
16187 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16188 return 1;
16189 }
16190
16191
16192 static PyObject *_wrap_ART_ERROR_get(void) {
16193 PyObject *pyobj;
16194
16195 {
16196 #if wxUSE_UNICODE
16197 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16198 #else
16199 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16200 #endif
16201 }
16202 return pyobj;
16203 }
16204
16205
16206 static int _wrap_ART_QUESTION_set(PyObject *) {
16207 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16208 return 1;
16209 }
16210
16211
16212 static PyObject *_wrap_ART_QUESTION_get(void) {
16213 PyObject *pyobj;
16214
16215 {
16216 #if wxUSE_UNICODE
16217 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16218 #else
16219 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16220 #endif
16221 }
16222 return pyobj;
16223 }
16224
16225
16226 static int _wrap_ART_WARNING_set(PyObject *) {
16227 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16228 return 1;
16229 }
16230
16231
16232 static PyObject *_wrap_ART_WARNING_get(void) {
16233 PyObject *pyobj;
16234
16235 {
16236 #if wxUSE_UNICODE
16237 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16238 #else
16239 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16240 #endif
16241 }
16242 return pyobj;
16243 }
16244
16245
16246 static int _wrap_ART_INFORMATION_set(PyObject *) {
16247 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16248 return 1;
16249 }
16250
16251
16252 static PyObject *_wrap_ART_INFORMATION_get(void) {
16253 PyObject *pyobj;
16254
16255 {
16256 #if wxUSE_UNICODE
16257 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16258 #else
16259 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16260 #endif
16261 }
16262 return pyobj;
16263 }
16264
16265
16266 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16267 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16268 return 1;
16269 }
16270
16271
16272 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16273 PyObject *pyobj;
16274
16275 {
16276 #if wxUSE_UNICODE
16277 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16278 #else
16279 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16280 #endif
16281 }
16282 return pyobj;
16283 }
16284
16285
16286 static int _wrap_ART_COPY_set(PyObject *) {
16287 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16288 return 1;
16289 }
16290
16291
16292 static PyObject *_wrap_ART_COPY_get(void) {
16293 PyObject *pyobj;
16294
16295 {
16296 #if wxUSE_UNICODE
16297 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16298 #else
16299 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16300 #endif
16301 }
16302 return pyobj;
16303 }
16304
16305
16306 static int _wrap_ART_CUT_set(PyObject *) {
16307 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16308 return 1;
16309 }
16310
16311
16312 static PyObject *_wrap_ART_CUT_get(void) {
16313 PyObject *pyobj;
16314
16315 {
16316 #if wxUSE_UNICODE
16317 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16318 #else
16319 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16320 #endif
16321 }
16322 return pyobj;
16323 }
16324
16325
16326 static int _wrap_ART_PASTE_set(PyObject *) {
16327 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16328 return 1;
16329 }
16330
16331
16332 static PyObject *_wrap_ART_PASTE_get(void) {
16333 PyObject *pyobj;
16334
16335 {
16336 #if wxUSE_UNICODE
16337 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16338 #else
16339 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16340 #endif
16341 }
16342 return pyobj;
16343 }
16344
16345
16346 static int _wrap_ART_DELETE_set(PyObject *) {
16347 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16348 return 1;
16349 }
16350
16351
16352 static PyObject *_wrap_ART_DELETE_get(void) {
16353 PyObject *pyobj;
16354
16355 {
16356 #if wxUSE_UNICODE
16357 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16358 #else
16359 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16360 #endif
16361 }
16362 return pyobj;
16363 }
16364
16365
16366 static int _wrap_ART_UNDO_set(PyObject *) {
16367 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16368 return 1;
16369 }
16370
16371
16372 static PyObject *_wrap_ART_UNDO_get(void) {
16373 PyObject *pyobj;
16374
16375 {
16376 #if wxUSE_UNICODE
16377 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16378 #else
16379 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16380 #endif
16381 }
16382 return pyobj;
16383 }
16384
16385
16386 static int _wrap_ART_REDO_set(PyObject *) {
16387 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16388 return 1;
16389 }
16390
16391
16392 static PyObject *_wrap_ART_REDO_get(void) {
16393 PyObject *pyobj;
16394
16395 {
16396 #if wxUSE_UNICODE
16397 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16398 #else
16399 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16400 #endif
16401 }
16402 return pyobj;
16403 }
16404
16405
16406 static int _wrap_ART_QUIT_set(PyObject *) {
16407 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16408 return 1;
16409 }
16410
16411
16412 static PyObject *_wrap_ART_QUIT_get(void) {
16413 PyObject *pyobj;
16414
16415 {
16416 #if wxUSE_UNICODE
16417 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16418 #else
16419 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16420 #endif
16421 }
16422 return pyobj;
16423 }
16424
16425
16426 static int _wrap_ART_FIND_set(PyObject *) {
16427 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16428 return 1;
16429 }
16430
16431
16432 static PyObject *_wrap_ART_FIND_get(void) {
16433 PyObject *pyobj;
16434
16435 {
16436 #if wxUSE_UNICODE
16437 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16438 #else
16439 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16440 #endif
16441 }
16442 return pyobj;
16443 }
16444
16445
16446 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16447 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16448 return 1;
16449 }
16450
16451
16452 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16453 PyObject *pyobj;
16454
16455 {
16456 #if wxUSE_UNICODE
16457 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16458 #else
16459 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16460 #endif
16461 }
16462 return pyobj;
16463 }
16464
16465
16466 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj;
16468 wxPyArtProvider *result;
16469 char *kwnames[] = {
16470 NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16474 {
16475 if (!wxPyCheckForApp()) SWIG_fail;
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (wxPyArtProvider *)new wxPyArtProvider();
16478
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16483 return resultobj;
16484 fail:
16485 return NULL;
16486 }
16487
16488
16489 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16490 PyObject *resultobj;
16491 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16492 PyObject *arg2 = (PyObject *) 0 ;
16493 PyObject *arg3 = (PyObject *) 0 ;
16494 PyObject * obj0 = 0 ;
16495 PyObject * obj1 = 0 ;
16496 PyObject * obj2 = 0 ;
16497 char *kwnames[] = {
16498 (char *) "self",(char *) "self",(char *) "_class", NULL
16499 };
16500
16501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16503 if (SWIG_arg_fail(1)) SWIG_fail;
16504 arg2 = obj1;
16505 arg3 = obj2;
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 (arg1)->_setCallbackInfo(arg2,arg3);
16509
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 Py_INCREF(Py_None); resultobj = Py_None;
16514 return resultobj;
16515 fail:
16516 return NULL;
16517 }
16518
16519
16520 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16521 PyObject *resultobj;
16522 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16523 PyObject * obj0 = 0 ;
16524 char *kwnames[] = {
16525 (char *) "provider", NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16530 if (SWIG_arg_fail(1)) SWIG_fail;
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 wxPyArtProvider::PushProvider(arg1);
16534
16535 wxPyEndAllowThreads(__tstate);
16536 if (PyErr_Occurred()) SWIG_fail;
16537 }
16538 Py_INCREF(Py_None); resultobj = Py_None;
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 bool result;
16548 char *kwnames[] = {
16549 NULL
16550 };
16551
16552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16553 {
16554 PyThreadState* __tstate = wxPyBeginAllowThreads();
16555 result = (bool)wxPyArtProvider::PopProvider();
16556
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 {
16561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16562 }
16563 return resultobj;
16564 fail:
16565 return NULL;
16566 }
16567
16568
16569 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16570 PyObject *resultobj;
16571 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16572 bool result;
16573 PyObject * obj0 = 0 ;
16574 char *kwnames[] = {
16575 (char *) "provider", NULL
16576 };
16577
16578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16580 if (SWIG_arg_fail(1)) SWIG_fail;
16581 {
16582 PyThreadState* __tstate = wxPyBeginAllowThreads();
16583 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16584
16585 wxPyEndAllowThreads(__tstate);
16586 if (PyErr_Occurred()) SWIG_fail;
16587 }
16588 {
16589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16590 }
16591 return resultobj;
16592 fail:
16593 return NULL;
16594 }
16595
16596
16597 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16598 PyObject *resultobj;
16599 wxString *arg1 = 0 ;
16600 wxString const &arg2_defvalue = wxPyART_OTHER ;
16601 wxString *arg2 = (wxString *) &arg2_defvalue ;
16602 wxSize const &arg3_defvalue = wxDefaultSize ;
16603 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16604 wxBitmap result;
16605 bool temp1 = false ;
16606 bool temp2 = false ;
16607 wxSize temp3 ;
16608 PyObject * obj0 = 0 ;
16609 PyObject * obj1 = 0 ;
16610 PyObject * obj2 = 0 ;
16611 char *kwnames[] = {
16612 (char *) "id",(char *) "client",(char *) "size", NULL
16613 };
16614
16615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16616 {
16617 arg1 = wxString_in_helper(obj0);
16618 if (arg1 == NULL) SWIG_fail;
16619 temp1 = true;
16620 }
16621 if (obj1) {
16622 {
16623 arg2 = wxString_in_helper(obj1);
16624 if (arg2 == NULL) SWIG_fail;
16625 temp2 = true;
16626 }
16627 }
16628 if (obj2) {
16629 {
16630 arg3 = &temp3;
16631 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16632 }
16633 }
16634 {
16635 if (!wxPyCheckForApp()) SWIG_fail;
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16638
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 {
16643 wxBitmap * resultptr;
16644 resultptr = new wxBitmap((wxBitmap &)(result));
16645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16646 }
16647 {
16648 if (temp1)
16649 delete arg1;
16650 }
16651 {
16652 if (temp2)
16653 delete arg2;
16654 }
16655 return resultobj;
16656 fail:
16657 {
16658 if (temp1)
16659 delete arg1;
16660 }
16661 {
16662 if (temp2)
16663 delete arg2;
16664 }
16665 return NULL;
16666 }
16667
16668
16669 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16670 PyObject *resultobj;
16671 wxString *arg1 = 0 ;
16672 wxString const &arg2_defvalue = wxPyART_OTHER ;
16673 wxString *arg2 = (wxString *) &arg2_defvalue ;
16674 wxSize const &arg3_defvalue = wxDefaultSize ;
16675 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16676 wxIcon result;
16677 bool temp1 = false ;
16678 bool temp2 = false ;
16679 wxSize temp3 ;
16680 PyObject * obj0 = 0 ;
16681 PyObject * obj1 = 0 ;
16682 PyObject * obj2 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "id",(char *) "client",(char *) "size", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16688 {
16689 arg1 = wxString_in_helper(obj0);
16690 if (arg1 == NULL) SWIG_fail;
16691 temp1 = true;
16692 }
16693 if (obj1) {
16694 {
16695 arg2 = wxString_in_helper(obj1);
16696 if (arg2 == NULL) SWIG_fail;
16697 temp2 = true;
16698 }
16699 }
16700 if (obj2) {
16701 {
16702 arg3 = &temp3;
16703 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16704 }
16705 }
16706 {
16707 if (!wxPyCheckForApp()) SWIG_fail;
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16710
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 {
16715 wxIcon * resultptr;
16716 resultptr = new wxIcon((wxIcon &)(result));
16717 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16718 }
16719 {
16720 if (temp1)
16721 delete arg1;
16722 }
16723 {
16724 if (temp2)
16725 delete arg2;
16726 }
16727 return resultobj;
16728 fail:
16729 {
16730 if (temp1)
16731 delete arg1;
16732 }
16733 {
16734 if (temp2)
16735 delete arg2;
16736 }
16737 return NULL;
16738 }
16739
16740
16741 static PyObject *_wrap_ArtProvider_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj;
16743 wxString *arg1 = 0 ;
16744 bool arg2 = (bool) false ;
16745 wxSize result;
16746 bool temp1 = false ;
16747 PyObject * obj0 = 0 ;
16748 PyObject * obj1 = 0 ;
16749 char *kwnames[] = {
16750 (char *) "client",(char *) "platform_dependent", NULL
16751 };
16752
16753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSize",kwnames,&obj0,&obj1)) goto fail;
16754 {
16755 arg1 = wxString_in_helper(obj0);
16756 if (arg1 == NULL) SWIG_fail;
16757 temp1 = true;
16758 }
16759 if (obj1) {
16760 {
16761 arg2 = (bool)(SWIG_As_bool(obj1));
16762 if (SWIG_arg_fail(2)) SWIG_fail;
16763 }
16764 }
16765 {
16766 PyThreadState* __tstate = wxPyBeginAllowThreads();
16767 result = wxPyArtProvider::GetSize((wxString const &)*arg1,arg2);
16768
16769 wxPyEndAllowThreads(__tstate);
16770 if (PyErr_Occurred()) SWIG_fail;
16771 }
16772 {
16773 wxSize * resultptr;
16774 resultptr = new wxSize((wxSize &)(result));
16775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16776 }
16777 {
16778 if (temp1)
16779 delete arg1;
16780 }
16781 return resultobj;
16782 fail:
16783 {
16784 if (temp1)
16785 delete arg1;
16786 }
16787 return NULL;
16788 }
16789
16790
16791 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj;
16793 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16794 PyObject * obj0 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 wxPyArtProvider_Destroy(arg1);
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 Py_INCREF(Py_None); resultobj = Py_None;
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16817 PyObject *obj;
16818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16819 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16820 Py_INCREF(obj);
16821 return Py_BuildValue((char *)"");
16822 }
16823 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj;
16825 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16826 PyObject * obj0 = 0 ;
16827 char *kwnames[] = {
16828 (char *) "self", NULL
16829 };
16830
16831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16833 if (SWIG_arg_fail(1)) SWIG_fail;
16834 {
16835 PyThreadState* __tstate = wxPyBeginAllowThreads();
16836 delete arg1;
16837
16838 wxPyEndAllowThreads(__tstate);
16839 if (PyErr_Occurred()) SWIG_fail;
16840 }
16841 Py_INCREF(Py_None); resultobj = Py_None;
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj;
16850 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16851 wxConfigBase *result;
16852 PyObject * obj0 = 0 ;
16853 char *kwnames[] = {
16854 (char *) "config", NULL
16855 };
16856
16857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16859 if (SWIG_arg_fail(1)) SWIG_fail;
16860 {
16861 PyThreadState* __tstate = wxPyBeginAllowThreads();
16862 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16863
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj;
16876 bool arg1 = (bool) true ;
16877 wxConfigBase *result;
16878 PyObject * obj0 = 0 ;
16879 char *kwnames[] = {
16880 (char *) "createOnDemand", NULL
16881 };
16882
16883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16884 if (obj0) {
16885 {
16886 arg1 = (bool)(SWIG_As_bool(obj0));
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 }
16889 }
16890 {
16891 PyThreadState* __tstate = wxPyBeginAllowThreads();
16892 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16893
16894 wxPyEndAllowThreads(__tstate);
16895 if (PyErr_Occurred()) SWIG_fail;
16896 }
16897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16898 return resultobj;
16899 fail:
16900 return NULL;
16901 }
16902
16903
16904 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16905 PyObject *resultobj;
16906 wxConfigBase *result;
16907 char *kwnames[] = {
16908 NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16912 {
16913 PyThreadState* __tstate = wxPyBeginAllowThreads();
16914 result = (wxConfigBase *)wxConfigBase::Create();
16915
16916 wxPyEndAllowThreads(__tstate);
16917 if (PyErr_Occurred()) SWIG_fail;
16918 }
16919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16920 return resultobj;
16921 fail:
16922 return NULL;
16923 }
16924
16925
16926 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16927 PyObject *resultobj;
16928 char *kwnames[] = {
16929 NULL
16930 };
16931
16932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 wxConfigBase::DontCreateOnDemand();
16936
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 Py_INCREF(Py_None); resultobj = Py_None;
16941 return resultobj;
16942 fail:
16943 return NULL;
16944 }
16945
16946
16947 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16948 PyObject *resultobj;
16949 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16950 wxString *arg2 = 0 ;
16951 bool temp2 = false ;
16952 PyObject * obj0 = 0 ;
16953 PyObject * obj1 = 0 ;
16954 char *kwnames[] = {
16955 (char *) "self",(char *) "path", NULL
16956 };
16957
16958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16960 if (SWIG_arg_fail(1)) SWIG_fail;
16961 {
16962 arg2 = wxString_in_helper(obj1);
16963 if (arg2 == NULL) SWIG_fail;
16964 temp2 = true;
16965 }
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 (arg1)->SetPath((wxString const &)*arg2);
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 Py_INCREF(Py_None); resultobj = Py_None;
16974 {
16975 if (temp2)
16976 delete arg2;
16977 }
16978 return resultobj;
16979 fail:
16980 {
16981 if (temp2)
16982 delete arg2;
16983 }
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16991 wxString *result;
16992 PyObject * obj0 = 0 ;
16993 char *kwnames[] = {
16994 (char *) "self", NULL
16995 };
16996
16997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16999 if (SWIG_arg_fail(1)) SWIG_fail;
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 {
17003 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17004 result = (wxString *) &_result_ref;
17005 }
17006
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 {
17011 #if wxUSE_UNICODE
17012 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17013 #else
17014 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17015 #endif
17016 }
17017 return resultobj;
17018 fail:
17019 return NULL;
17020 }
17021
17022
17023 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17024 PyObject *resultobj;
17025 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17026 PyObject *result;
17027 PyObject * obj0 = 0 ;
17028 char *kwnames[] = {
17029 (char *) "self", NULL
17030 };
17031
17032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17034 if (SWIG_arg_fail(1)) SWIG_fail;
17035 {
17036 PyThreadState* __tstate = wxPyBeginAllowThreads();
17037 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17038
17039 wxPyEndAllowThreads(__tstate);
17040 if (PyErr_Occurred()) SWIG_fail;
17041 }
17042 resultobj = result;
17043 return resultobj;
17044 fail:
17045 return NULL;
17046 }
17047
17048
17049 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj;
17051 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17052 long arg2 ;
17053 PyObject *result;
17054 PyObject * obj0 = 0 ;
17055 PyObject * obj1 = 0 ;
17056 char *kwnames[] = {
17057 (char *) "self",(char *) "index", NULL
17058 };
17059
17060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17062 if (SWIG_arg_fail(1)) SWIG_fail;
17063 {
17064 arg2 = (long)(SWIG_As_long(obj1));
17065 if (SWIG_arg_fail(2)) SWIG_fail;
17066 }
17067 {
17068 PyThreadState* __tstate = wxPyBeginAllowThreads();
17069 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17070
17071 wxPyEndAllowThreads(__tstate);
17072 if (PyErr_Occurred()) SWIG_fail;
17073 }
17074 resultobj = result;
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17084 PyObject *result;
17085 PyObject * obj0 = 0 ;
17086 char *kwnames[] = {
17087 (char *) "self", NULL
17088 };
17089
17090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17092 if (SWIG_arg_fail(1)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17096
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 resultobj = result;
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj;
17109 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17110 long arg2 ;
17111 PyObject *result;
17112 PyObject * obj0 = 0 ;
17113 PyObject * obj1 = 0 ;
17114 char *kwnames[] = {
17115 (char *) "self",(char *) "index", NULL
17116 };
17117
17118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17120 if (SWIG_arg_fail(1)) SWIG_fail;
17121 {
17122 arg2 = (long)(SWIG_As_long(obj1));
17123 if (SWIG_arg_fail(2)) SWIG_fail;
17124 }
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17128
17129 wxPyEndAllowThreads(__tstate);
17130 if (PyErr_Occurred()) SWIG_fail;
17131 }
17132 resultobj = result;
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj;
17141 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17142 bool arg2 = (bool) false ;
17143 size_t result;
17144 PyObject * obj0 = 0 ;
17145 PyObject * obj1 = 0 ;
17146 char *kwnames[] = {
17147 (char *) "self",(char *) "recursive", NULL
17148 };
17149
17150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17152 if (SWIG_arg_fail(1)) SWIG_fail;
17153 if (obj1) {
17154 {
17155 arg2 = (bool)(SWIG_As_bool(obj1));
17156 if (SWIG_arg_fail(2)) SWIG_fail;
17157 }
17158 }
17159 {
17160 PyThreadState* __tstate = wxPyBeginAllowThreads();
17161 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17162
17163 wxPyEndAllowThreads(__tstate);
17164 if (PyErr_Occurred()) SWIG_fail;
17165 }
17166 {
17167 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17168 }
17169 return resultobj;
17170 fail:
17171 return NULL;
17172 }
17173
17174
17175 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17176 PyObject *resultobj;
17177 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17178 bool arg2 = (bool) false ;
17179 size_t result;
17180 PyObject * obj0 = 0 ;
17181 PyObject * obj1 = 0 ;
17182 char *kwnames[] = {
17183 (char *) "self",(char *) "recursive", NULL
17184 };
17185
17186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",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 if (obj1) {
17190 {
17191 arg2 = (bool)(SWIG_As_bool(obj1));
17192 if (SWIG_arg_fail(2)) SWIG_fail;
17193 }
17194 }
17195 {
17196 PyThreadState* __tstate = wxPyBeginAllowThreads();
17197 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17198
17199 wxPyEndAllowThreads(__tstate);
17200 if (PyErr_Occurred()) SWIG_fail;
17201 }
17202 {
17203 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17204 }
17205 return resultobj;
17206 fail:
17207 return NULL;
17208 }
17209
17210
17211 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17212 PyObject *resultobj;
17213 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17214 wxString *arg2 = 0 ;
17215 bool result;
17216 bool temp2 = false ;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17219 char *kwnames[] = {
17220 (char *) "self",(char *) "name", NULL
17221 };
17222
17223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17225 if (SWIG_arg_fail(1)) SWIG_fail;
17226 {
17227 arg2 = wxString_in_helper(obj1);
17228 if (arg2 == NULL) SWIG_fail;
17229 temp2 = true;
17230 }
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17234
17235 wxPyEndAllowThreads(__tstate);
17236 if (PyErr_Occurred()) SWIG_fail;
17237 }
17238 {
17239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17240 }
17241 {
17242 if (temp2)
17243 delete arg2;
17244 }
17245 return resultobj;
17246 fail:
17247 {
17248 if (temp2)
17249 delete arg2;
17250 }
17251 return NULL;
17252 }
17253
17254
17255 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17256 PyObject *resultobj;
17257 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17258 wxString *arg2 = 0 ;
17259 bool result;
17260 bool temp2 = false ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263 char *kwnames[] = {
17264 (char *) "self",(char *) "name", NULL
17265 };
17266
17267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17269 if (SWIG_arg_fail(1)) SWIG_fail;
17270 {
17271 arg2 = wxString_in_helper(obj1);
17272 if (arg2 == NULL) SWIG_fail;
17273 temp2 = true;
17274 }
17275 {
17276 PyThreadState* __tstate = wxPyBeginAllowThreads();
17277 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17278
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 {
17283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17284 }
17285 {
17286 if (temp2)
17287 delete arg2;
17288 }
17289 return resultobj;
17290 fail:
17291 {
17292 if (temp2)
17293 delete arg2;
17294 }
17295 return NULL;
17296 }
17297
17298
17299 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17300 PyObject *resultobj;
17301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17302 wxString *arg2 = 0 ;
17303 bool result;
17304 bool temp2 = false ;
17305 PyObject * obj0 = 0 ;
17306 PyObject * obj1 = 0 ;
17307 char *kwnames[] = {
17308 (char *) "self",(char *) "name", NULL
17309 };
17310
17311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17313 if (SWIG_arg_fail(1)) SWIG_fail;
17314 {
17315 arg2 = wxString_in_helper(obj1);
17316 if (arg2 == NULL) SWIG_fail;
17317 temp2 = true;
17318 }
17319 {
17320 PyThreadState* __tstate = wxPyBeginAllowThreads();
17321 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17322
17323 wxPyEndAllowThreads(__tstate);
17324 if (PyErr_Occurred()) SWIG_fail;
17325 }
17326 {
17327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17328 }
17329 {
17330 if (temp2)
17331 delete arg2;
17332 }
17333 return resultobj;
17334 fail:
17335 {
17336 if (temp2)
17337 delete arg2;
17338 }
17339 return NULL;
17340 }
17341
17342
17343 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17344 PyObject *resultobj;
17345 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17346 wxString *arg2 = 0 ;
17347 wxConfigBase::EntryType result;
17348 bool temp2 = false ;
17349 PyObject * obj0 = 0 ;
17350 PyObject * obj1 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self",(char *) "name", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 arg2 = wxString_in_helper(obj1);
17360 if (arg2 == NULL) SWIG_fail;
17361 temp2 = true;
17362 }
17363 {
17364 PyThreadState* __tstate = wxPyBeginAllowThreads();
17365 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17366
17367 wxPyEndAllowThreads(__tstate);
17368 if (PyErr_Occurred()) SWIG_fail;
17369 }
17370 resultobj = SWIG_From_int((result));
17371 {
17372 if (temp2)
17373 delete arg2;
17374 }
17375 return resultobj;
17376 fail:
17377 {
17378 if (temp2)
17379 delete arg2;
17380 }
17381 return NULL;
17382 }
17383
17384
17385 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17386 PyObject *resultobj;
17387 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17388 wxString *arg2 = 0 ;
17389 wxString const &arg3_defvalue = wxPyEmptyString ;
17390 wxString *arg3 = (wxString *) &arg3_defvalue ;
17391 wxString result;
17392 bool temp2 = false ;
17393 bool temp3 = false ;
17394 PyObject * obj0 = 0 ;
17395 PyObject * obj1 = 0 ;
17396 PyObject * obj2 = 0 ;
17397 char *kwnames[] = {
17398 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17399 };
17400
17401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17403 if (SWIG_arg_fail(1)) SWIG_fail;
17404 {
17405 arg2 = wxString_in_helper(obj1);
17406 if (arg2 == NULL) SWIG_fail;
17407 temp2 = true;
17408 }
17409 if (obj2) {
17410 {
17411 arg3 = wxString_in_helper(obj2);
17412 if (arg3 == NULL) SWIG_fail;
17413 temp3 = true;
17414 }
17415 }
17416 {
17417 PyThreadState* __tstate = wxPyBeginAllowThreads();
17418 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17419
17420 wxPyEndAllowThreads(__tstate);
17421 if (PyErr_Occurred()) SWIG_fail;
17422 }
17423 {
17424 #if wxUSE_UNICODE
17425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17426 #else
17427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17428 #endif
17429 }
17430 {
17431 if (temp2)
17432 delete arg2;
17433 }
17434 {
17435 if (temp3)
17436 delete arg3;
17437 }
17438 return resultobj;
17439 fail:
17440 {
17441 if (temp2)
17442 delete arg2;
17443 }
17444 {
17445 if (temp3)
17446 delete arg3;
17447 }
17448 return NULL;
17449 }
17450
17451
17452 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17453 PyObject *resultobj;
17454 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17455 wxString *arg2 = 0 ;
17456 long arg3 = (long) 0 ;
17457 long result;
17458 bool temp2 = false ;
17459 PyObject * obj0 = 0 ;
17460 PyObject * obj1 = 0 ;
17461 PyObject * obj2 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 arg2 = wxString_in_helper(obj1);
17471 if (arg2 == NULL) SWIG_fail;
17472 temp2 = true;
17473 }
17474 if (obj2) {
17475 {
17476 arg3 = (long)(SWIG_As_long(obj2));
17477 if (SWIG_arg_fail(3)) SWIG_fail;
17478 }
17479 }
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17483
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = SWIG_From_long((long)(result));
17489 }
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 return resultobj;
17495 fail:
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 return NULL;
17501 }
17502
17503
17504 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj;
17506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17507 wxString *arg2 = 0 ;
17508 double arg3 = (double) 0.0 ;
17509 double result;
17510 bool temp2 = false ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 PyObject * obj2 = 0 ;
17514 char *kwnames[] = {
17515 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17516 };
17517
17518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17520 if (SWIG_arg_fail(1)) SWIG_fail;
17521 {
17522 arg2 = wxString_in_helper(obj1);
17523 if (arg2 == NULL) SWIG_fail;
17524 temp2 = true;
17525 }
17526 if (obj2) {
17527 {
17528 arg3 = (double)(SWIG_As_double(obj2));
17529 if (SWIG_arg_fail(3)) SWIG_fail;
17530 }
17531 }
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17535
17536 wxPyEndAllowThreads(__tstate);
17537 if (PyErr_Occurred()) SWIG_fail;
17538 }
17539 {
17540 resultobj = SWIG_From_double((double)(result));
17541 }
17542 {
17543 if (temp2)
17544 delete arg2;
17545 }
17546 return resultobj;
17547 fail:
17548 {
17549 if (temp2)
17550 delete arg2;
17551 }
17552 return NULL;
17553 }
17554
17555
17556 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj;
17558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17559 wxString *arg2 = 0 ;
17560 bool arg3 = (bool) false ;
17561 bool result;
17562 bool temp2 = false ;
17563 PyObject * obj0 = 0 ;
17564 PyObject * obj1 = 0 ;
17565 PyObject * obj2 = 0 ;
17566 char *kwnames[] = {
17567 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17568 };
17569
17570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17572 if (SWIG_arg_fail(1)) SWIG_fail;
17573 {
17574 arg2 = wxString_in_helper(obj1);
17575 if (arg2 == NULL) SWIG_fail;
17576 temp2 = true;
17577 }
17578 if (obj2) {
17579 {
17580 arg3 = (bool)(SWIG_As_bool(obj2));
17581 if (SWIG_arg_fail(3)) SWIG_fail;
17582 }
17583 }
17584 {
17585 PyThreadState* __tstate = wxPyBeginAllowThreads();
17586 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17587
17588 wxPyEndAllowThreads(__tstate);
17589 if (PyErr_Occurred()) SWIG_fail;
17590 }
17591 {
17592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17593 }
17594 {
17595 if (temp2)
17596 delete arg2;
17597 }
17598 return resultobj;
17599 fail:
17600 {
17601 if (temp2)
17602 delete arg2;
17603 }
17604 return NULL;
17605 }
17606
17607
17608 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj;
17610 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17611 wxString *arg2 = 0 ;
17612 wxString *arg3 = 0 ;
17613 bool result;
17614 bool temp2 = false ;
17615 bool temp3 = false ;
17616 PyObject * obj0 = 0 ;
17617 PyObject * obj1 = 0 ;
17618 PyObject * obj2 = 0 ;
17619 char *kwnames[] = {
17620 (char *) "self",(char *) "key",(char *) "value", NULL
17621 };
17622
17623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17625 if (SWIG_arg_fail(1)) SWIG_fail;
17626 {
17627 arg2 = wxString_in_helper(obj1);
17628 if (arg2 == NULL) SWIG_fail;
17629 temp2 = true;
17630 }
17631 {
17632 arg3 = wxString_in_helper(obj2);
17633 if (arg3 == NULL) SWIG_fail;
17634 temp3 = true;
17635 }
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17639
17640 wxPyEndAllowThreads(__tstate);
17641 if (PyErr_Occurred()) SWIG_fail;
17642 }
17643 {
17644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17645 }
17646 {
17647 if (temp2)
17648 delete arg2;
17649 }
17650 {
17651 if (temp3)
17652 delete arg3;
17653 }
17654 return resultobj;
17655 fail:
17656 {
17657 if (temp2)
17658 delete arg2;
17659 }
17660 {
17661 if (temp3)
17662 delete arg3;
17663 }
17664 return NULL;
17665 }
17666
17667
17668 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj;
17670 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17671 wxString *arg2 = 0 ;
17672 long arg3 ;
17673 bool result;
17674 bool temp2 = false ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 PyObject * obj2 = 0 ;
17678 char *kwnames[] = {
17679 (char *) "self",(char *) "key",(char *) "value", NULL
17680 };
17681
17682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17684 if (SWIG_arg_fail(1)) SWIG_fail;
17685 {
17686 arg2 = wxString_in_helper(obj1);
17687 if (arg2 == NULL) SWIG_fail;
17688 temp2 = true;
17689 }
17690 {
17691 arg3 = (long)(SWIG_As_long(obj2));
17692 if (SWIG_arg_fail(3)) SWIG_fail;
17693 }
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17697
17698 wxPyEndAllowThreads(__tstate);
17699 if (PyErr_Occurred()) SWIG_fail;
17700 }
17701 {
17702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17703 }
17704 {
17705 if (temp2)
17706 delete arg2;
17707 }
17708 return resultobj;
17709 fail:
17710 {
17711 if (temp2)
17712 delete arg2;
17713 }
17714 return NULL;
17715 }
17716
17717
17718 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj;
17720 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17721 wxString *arg2 = 0 ;
17722 double arg3 ;
17723 bool result;
17724 bool temp2 = false ;
17725 PyObject * obj0 = 0 ;
17726 PyObject * obj1 = 0 ;
17727 PyObject * obj2 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "self",(char *) "key",(char *) "value", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17734 if (SWIG_arg_fail(1)) SWIG_fail;
17735 {
17736 arg2 = wxString_in_helper(obj1);
17737 if (arg2 == NULL) SWIG_fail;
17738 temp2 = true;
17739 }
17740 {
17741 arg3 = (double)(SWIG_As_double(obj2));
17742 if (SWIG_arg_fail(3)) SWIG_fail;
17743 }
17744 {
17745 PyThreadState* __tstate = wxPyBeginAllowThreads();
17746 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17747
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 {
17752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17753 }
17754 {
17755 if (temp2)
17756 delete arg2;
17757 }
17758 return resultobj;
17759 fail:
17760 {
17761 if (temp2)
17762 delete arg2;
17763 }
17764 return NULL;
17765 }
17766
17767
17768 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17769 PyObject *resultobj;
17770 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17771 wxString *arg2 = 0 ;
17772 bool arg3 ;
17773 bool result;
17774 bool temp2 = false ;
17775 PyObject * obj0 = 0 ;
17776 PyObject * obj1 = 0 ;
17777 PyObject * obj2 = 0 ;
17778 char *kwnames[] = {
17779 (char *) "self",(char *) "key",(char *) "value", NULL
17780 };
17781
17782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17784 if (SWIG_arg_fail(1)) SWIG_fail;
17785 {
17786 arg2 = wxString_in_helper(obj1);
17787 if (arg2 == NULL) SWIG_fail;
17788 temp2 = true;
17789 }
17790 {
17791 arg3 = (bool)(SWIG_As_bool(obj2));
17792 if (SWIG_arg_fail(3)) SWIG_fail;
17793 }
17794 {
17795 PyThreadState* __tstate = wxPyBeginAllowThreads();
17796 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17797
17798 wxPyEndAllowThreads(__tstate);
17799 if (PyErr_Occurred()) SWIG_fail;
17800 }
17801 {
17802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17803 }
17804 {
17805 if (temp2)
17806 delete arg2;
17807 }
17808 return resultobj;
17809 fail:
17810 {
17811 if (temp2)
17812 delete arg2;
17813 }
17814 return NULL;
17815 }
17816
17817
17818 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj;
17820 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17821 bool arg2 = (bool) false ;
17822 bool result;
17823 PyObject * obj0 = 0 ;
17824 PyObject * obj1 = 0 ;
17825 char *kwnames[] = {
17826 (char *) "self",(char *) "currentOnly", NULL
17827 };
17828
17829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17831 if (SWIG_arg_fail(1)) SWIG_fail;
17832 if (obj1) {
17833 {
17834 arg2 = (bool)(SWIG_As_bool(obj1));
17835 if (SWIG_arg_fail(2)) SWIG_fail;
17836 }
17837 }
17838 {
17839 PyThreadState* __tstate = wxPyBeginAllowThreads();
17840 result = (bool)(arg1)->Flush(arg2);
17841
17842 wxPyEndAllowThreads(__tstate);
17843 if (PyErr_Occurred()) SWIG_fail;
17844 }
17845 {
17846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17847 }
17848 return resultobj;
17849 fail:
17850 return NULL;
17851 }
17852
17853
17854 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17855 PyObject *resultobj;
17856 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17857 wxString *arg2 = 0 ;
17858 wxString *arg3 = 0 ;
17859 bool result;
17860 bool temp2 = false ;
17861 bool temp3 = false ;
17862 PyObject * obj0 = 0 ;
17863 PyObject * obj1 = 0 ;
17864 PyObject * obj2 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 arg2 = wxString_in_helper(obj1);
17874 if (arg2 == NULL) SWIG_fail;
17875 temp2 = true;
17876 }
17877 {
17878 arg3 = wxString_in_helper(obj2);
17879 if (arg3 == NULL) SWIG_fail;
17880 temp3 = true;
17881 }
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17891 }
17892 {
17893 if (temp2)
17894 delete arg2;
17895 }
17896 {
17897 if (temp3)
17898 delete arg3;
17899 }
17900 return resultobj;
17901 fail:
17902 {
17903 if (temp2)
17904 delete arg2;
17905 }
17906 {
17907 if (temp3)
17908 delete arg3;
17909 }
17910 return NULL;
17911 }
17912
17913
17914 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj;
17916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17917 wxString *arg2 = 0 ;
17918 wxString *arg3 = 0 ;
17919 bool result;
17920 bool temp2 = false ;
17921 bool temp3 = false ;
17922 PyObject * obj0 = 0 ;
17923 PyObject * obj1 = 0 ;
17924 PyObject * obj2 = 0 ;
17925 char *kwnames[] = {
17926 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17927 };
17928
17929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17931 if (SWIG_arg_fail(1)) SWIG_fail;
17932 {
17933 arg2 = wxString_in_helper(obj1);
17934 if (arg2 == NULL) SWIG_fail;
17935 temp2 = true;
17936 }
17937 {
17938 arg3 = wxString_in_helper(obj2);
17939 if (arg3 == NULL) SWIG_fail;
17940 temp3 = true;
17941 }
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17945
17946 wxPyEndAllowThreads(__tstate);
17947 if (PyErr_Occurred()) SWIG_fail;
17948 }
17949 {
17950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17951 }
17952 {
17953 if (temp2)
17954 delete arg2;
17955 }
17956 {
17957 if (temp3)
17958 delete arg3;
17959 }
17960 return resultobj;
17961 fail:
17962 {
17963 if (temp2)
17964 delete arg2;
17965 }
17966 {
17967 if (temp3)
17968 delete arg3;
17969 }
17970 return NULL;
17971 }
17972
17973
17974 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj;
17976 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17977 wxString *arg2 = 0 ;
17978 bool arg3 = (bool) true ;
17979 bool result;
17980 bool temp2 = false ;
17981 PyObject * obj0 = 0 ;
17982 PyObject * obj1 = 0 ;
17983 PyObject * obj2 = 0 ;
17984 char *kwnames[] = {
17985 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17986 };
17987
17988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17990 if (SWIG_arg_fail(1)) SWIG_fail;
17991 {
17992 arg2 = wxString_in_helper(obj1);
17993 if (arg2 == NULL) SWIG_fail;
17994 temp2 = true;
17995 }
17996 if (obj2) {
17997 {
17998 arg3 = (bool)(SWIG_As_bool(obj2));
17999 if (SWIG_arg_fail(3)) SWIG_fail;
18000 }
18001 }
18002 {
18003 PyThreadState* __tstate = wxPyBeginAllowThreads();
18004 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18005
18006 wxPyEndAllowThreads(__tstate);
18007 if (PyErr_Occurred()) SWIG_fail;
18008 }
18009 {
18010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18011 }
18012 {
18013 if (temp2)
18014 delete arg2;
18015 }
18016 return resultobj;
18017 fail:
18018 {
18019 if (temp2)
18020 delete arg2;
18021 }
18022 return NULL;
18023 }
18024
18025
18026 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18027 PyObject *resultobj;
18028 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18029 wxString *arg2 = 0 ;
18030 bool result;
18031 bool temp2 = false ;
18032 PyObject * obj0 = 0 ;
18033 PyObject * obj1 = 0 ;
18034 char *kwnames[] = {
18035 (char *) "self",(char *) "key", NULL
18036 };
18037
18038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18040 if (SWIG_arg_fail(1)) SWIG_fail;
18041 {
18042 arg2 = wxString_in_helper(obj1);
18043 if (arg2 == NULL) SWIG_fail;
18044 temp2 = true;
18045 }
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18049
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 {
18054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18055 }
18056 {
18057 if (temp2)
18058 delete arg2;
18059 }
18060 return resultobj;
18061 fail:
18062 {
18063 if (temp2)
18064 delete arg2;
18065 }
18066 return NULL;
18067 }
18068
18069
18070 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj;
18072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18073 bool result;
18074 PyObject * obj0 = 0 ;
18075 char *kwnames[] = {
18076 (char *) "self", NULL
18077 };
18078
18079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18081 if (SWIG_arg_fail(1)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (bool)(arg1)->DeleteAll();
18085
18086 wxPyEndAllowThreads(__tstate);
18087 if (PyErr_Occurred()) SWIG_fail;
18088 }
18089 {
18090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18091 }
18092 return resultobj;
18093 fail:
18094 return NULL;
18095 }
18096
18097
18098 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18099 PyObject *resultobj;
18100 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18101 bool arg2 = (bool) true ;
18102 PyObject * obj0 = 0 ;
18103 PyObject * obj1 = 0 ;
18104 char *kwnames[] = {
18105 (char *) "self",(char *) "doIt", NULL
18106 };
18107
18108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18110 if (SWIG_arg_fail(1)) SWIG_fail;
18111 if (obj1) {
18112 {
18113 arg2 = (bool)(SWIG_As_bool(obj1));
18114 if (SWIG_arg_fail(2)) SWIG_fail;
18115 }
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 (arg1)->SetExpandEnvVars(arg2);
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 Py_INCREF(Py_None); resultobj = Py_None;
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18132 PyObject *resultobj;
18133 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18134 bool result;
18135 PyObject * obj0 = 0 ;
18136 char *kwnames[] = {
18137 (char *) "self", NULL
18138 };
18139
18140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18142 if (SWIG_arg_fail(1)) SWIG_fail;
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18152 }
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj;
18161 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18162 bool arg2 = (bool) true ;
18163 PyObject * obj0 = 0 ;
18164 PyObject * obj1 = 0 ;
18165 char *kwnames[] = {
18166 (char *) "self",(char *) "doIt", NULL
18167 };
18168
18169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18171 if (SWIG_arg_fail(1)) SWIG_fail;
18172 if (obj1) {
18173 {
18174 arg2 = (bool)(SWIG_As_bool(obj1));
18175 if (SWIG_arg_fail(2)) SWIG_fail;
18176 }
18177 }
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 (arg1)->SetRecordDefaults(arg2);
18181
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 Py_INCREF(Py_None); resultobj = Py_None;
18186 return resultobj;
18187 fail:
18188 return NULL;
18189 }
18190
18191
18192 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18193 PyObject *resultobj;
18194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18195 bool result;
18196 PyObject * obj0 = 0 ;
18197 char *kwnames[] = {
18198 (char *) "self", NULL
18199 };
18200
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(1)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18207
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 {
18212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18213 }
18214 return resultobj;
18215 fail:
18216 return NULL;
18217 }
18218
18219
18220 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18221 PyObject *resultobj;
18222 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18223 wxString *arg2 = 0 ;
18224 wxString result;
18225 bool temp2 = false ;
18226 PyObject * obj0 = 0 ;
18227 PyObject * obj1 = 0 ;
18228 char *kwnames[] = {
18229 (char *) "self",(char *) "str", NULL
18230 };
18231
18232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18234 if (SWIG_arg_fail(1)) SWIG_fail;
18235 {
18236 arg2 = wxString_in_helper(obj1);
18237 if (arg2 == NULL) SWIG_fail;
18238 temp2 = true;
18239 }
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18243
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 {
18248 #if wxUSE_UNICODE
18249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18250 #else
18251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18252 #endif
18253 }
18254 {
18255 if (temp2)
18256 delete arg2;
18257 }
18258 return resultobj;
18259 fail:
18260 {
18261 if (temp2)
18262 delete arg2;
18263 }
18264 return NULL;
18265 }
18266
18267
18268 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18269 PyObject *resultobj;
18270 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18271 wxString result;
18272 PyObject * obj0 = 0 ;
18273 char *kwnames[] = {
18274 (char *) "self", NULL
18275 };
18276
18277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18279 if (SWIG_arg_fail(1)) SWIG_fail;
18280 {
18281 PyThreadState* __tstate = wxPyBeginAllowThreads();
18282 result = ((wxConfigBase const *)arg1)->GetAppName();
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 {
18288 #if wxUSE_UNICODE
18289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18290 #else
18291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18292 #endif
18293 }
18294 return resultobj;
18295 fail:
18296 return NULL;
18297 }
18298
18299
18300 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18301 PyObject *resultobj;
18302 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18303 wxString result;
18304 PyObject * obj0 = 0 ;
18305 char *kwnames[] = {
18306 (char *) "self", NULL
18307 };
18308
18309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18311 if (SWIG_arg_fail(1)) SWIG_fail;
18312 {
18313 PyThreadState* __tstate = wxPyBeginAllowThreads();
18314 result = ((wxConfigBase const *)arg1)->GetVendorName();
18315
18316 wxPyEndAllowThreads(__tstate);
18317 if (PyErr_Occurred()) SWIG_fail;
18318 }
18319 {
18320 #if wxUSE_UNICODE
18321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18322 #else
18323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18324 #endif
18325 }
18326 return resultobj;
18327 fail:
18328 return NULL;
18329 }
18330
18331
18332 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18333 PyObject *resultobj;
18334 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18335 wxString *arg2 = 0 ;
18336 bool temp2 = false ;
18337 PyObject * obj0 = 0 ;
18338 PyObject * obj1 = 0 ;
18339 char *kwnames[] = {
18340 (char *) "self",(char *) "appName", NULL
18341 };
18342
18343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 {
18347 arg2 = wxString_in_helper(obj1);
18348 if (arg2 == NULL) SWIG_fail;
18349 temp2 = true;
18350 }
18351 {
18352 PyThreadState* __tstate = wxPyBeginAllowThreads();
18353 (arg1)->SetAppName((wxString const &)*arg2);
18354
18355 wxPyEndAllowThreads(__tstate);
18356 if (PyErr_Occurred()) SWIG_fail;
18357 }
18358 Py_INCREF(Py_None); resultobj = Py_None;
18359 {
18360 if (temp2)
18361 delete arg2;
18362 }
18363 return resultobj;
18364 fail:
18365 {
18366 if (temp2)
18367 delete arg2;
18368 }
18369 return NULL;
18370 }
18371
18372
18373 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18374 PyObject *resultobj;
18375 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18376 wxString *arg2 = 0 ;
18377 bool temp2 = false ;
18378 PyObject * obj0 = 0 ;
18379 PyObject * obj1 = 0 ;
18380 char *kwnames[] = {
18381 (char *) "self",(char *) "vendorName", NULL
18382 };
18383
18384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18386 if (SWIG_arg_fail(1)) SWIG_fail;
18387 {
18388 arg2 = wxString_in_helper(obj1);
18389 if (arg2 == NULL) SWIG_fail;
18390 temp2 = true;
18391 }
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 (arg1)->SetVendorName((wxString const &)*arg2);
18395
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 Py_INCREF(Py_None); resultobj = Py_None;
18400 {
18401 if (temp2)
18402 delete arg2;
18403 }
18404 return resultobj;
18405 fail:
18406 {
18407 if (temp2)
18408 delete arg2;
18409 }
18410 return NULL;
18411 }
18412
18413
18414 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj;
18416 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18417 long arg2 ;
18418 PyObject * obj0 = 0 ;
18419 PyObject * obj1 = 0 ;
18420 char *kwnames[] = {
18421 (char *) "self",(char *) "style", NULL
18422 };
18423
18424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18426 if (SWIG_arg_fail(1)) SWIG_fail;
18427 {
18428 arg2 = (long)(SWIG_As_long(obj1));
18429 if (SWIG_arg_fail(2)) SWIG_fail;
18430 }
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 (arg1)->SetStyle(arg2);
18434
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 Py_INCREF(Py_None); resultobj = Py_None;
18439 return resultobj;
18440 fail:
18441 return NULL;
18442 }
18443
18444
18445 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18446 PyObject *resultobj;
18447 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18448 long result;
18449 PyObject * obj0 = 0 ;
18450 char *kwnames[] = {
18451 (char *) "self", NULL
18452 };
18453
18454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18456 if (SWIG_arg_fail(1)) SWIG_fail;
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18460
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 {
18465 resultobj = SWIG_From_long((long)(result));
18466 }
18467 return resultobj;
18468 fail:
18469 return NULL;
18470 }
18471
18472
18473 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18474 PyObject *obj;
18475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18476 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18477 Py_INCREF(obj);
18478 return Py_BuildValue((char *)"");
18479 }
18480 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18481 PyObject *resultobj;
18482 wxString const &arg1_defvalue = wxPyEmptyString ;
18483 wxString *arg1 = (wxString *) &arg1_defvalue ;
18484 wxString const &arg2_defvalue = wxPyEmptyString ;
18485 wxString *arg2 = (wxString *) &arg2_defvalue ;
18486 wxString const &arg3_defvalue = wxPyEmptyString ;
18487 wxString *arg3 = (wxString *) &arg3_defvalue ;
18488 wxString const &arg4_defvalue = wxPyEmptyString ;
18489 wxString *arg4 = (wxString *) &arg4_defvalue ;
18490 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18491 wxConfig *result;
18492 bool temp1 = false ;
18493 bool temp2 = false ;
18494 bool temp3 = false ;
18495 bool temp4 = false ;
18496 PyObject * obj0 = 0 ;
18497 PyObject * obj1 = 0 ;
18498 PyObject * obj2 = 0 ;
18499 PyObject * obj3 = 0 ;
18500 PyObject * obj4 = 0 ;
18501 char *kwnames[] = {
18502 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18503 };
18504
18505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18506 if (obj0) {
18507 {
18508 arg1 = wxString_in_helper(obj0);
18509 if (arg1 == NULL) SWIG_fail;
18510 temp1 = true;
18511 }
18512 }
18513 if (obj1) {
18514 {
18515 arg2 = wxString_in_helper(obj1);
18516 if (arg2 == NULL) SWIG_fail;
18517 temp2 = true;
18518 }
18519 }
18520 if (obj2) {
18521 {
18522 arg3 = wxString_in_helper(obj2);
18523 if (arg3 == NULL) SWIG_fail;
18524 temp3 = true;
18525 }
18526 }
18527 if (obj3) {
18528 {
18529 arg4 = wxString_in_helper(obj3);
18530 if (arg4 == NULL) SWIG_fail;
18531 temp4 = true;
18532 }
18533 }
18534 if (obj4) {
18535 {
18536 arg5 = (long)(SWIG_As_long(obj4));
18537 if (SWIG_arg_fail(5)) SWIG_fail;
18538 }
18539 }
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18543
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18548 {
18549 if (temp1)
18550 delete arg1;
18551 }
18552 {
18553 if (temp2)
18554 delete arg2;
18555 }
18556 {
18557 if (temp3)
18558 delete arg3;
18559 }
18560 {
18561 if (temp4)
18562 delete arg4;
18563 }
18564 return resultobj;
18565 fail:
18566 {
18567 if (temp1)
18568 delete arg1;
18569 }
18570 {
18571 if (temp2)
18572 delete arg2;
18573 }
18574 {
18575 if (temp3)
18576 delete arg3;
18577 }
18578 {
18579 if (temp4)
18580 delete arg4;
18581 }
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxConfig *arg1 = (wxConfig *) 0 ;
18589 PyObject * obj0 = 0 ;
18590 char *kwnames[] = {
18591 (char *) "self", NULL
18592 };
18593
18594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18596 if (SWIG_arg_fail(1)) SWIG_fail;
18597 {
18598 PyThreadState* __tstate = wxPyBeginAllowThreads();
18599 delete arg1;
18600
18601 wxPyEndAllowThreads(__tstate);
18602 if (PyErr_Occurred()) SWIG_fail;
18603 }
18604 Py_INCREF(Py_None); resultobj = Py_None;
18605 return resultobj;
18606 fail:
18607 return NULL;
18608 }
18609
18610
18611 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18612 PyObject *obj;
18613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18614 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18615 Py_INCREF(obj);
18616 return Py_BuildValue((char *)"");
18617 }
18618 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj;
18620 wxString const &arg1_defvalue = wxPyEmptyString ;
18621 wxString *arg1 = (wxString *) &arg1_defvalue ;
18622 wxString const &arg2_defvalue = wxPyEmptyString ;
18623 wxString *arg2 = (wxString *) &arg2_defvalue ;
18624 wxString const &arg3_defvalue = wxPyEmptyString ;
18625 wxString *arg3 = (wxString *) &arg3_defvalue ;
18626 wxString const &arg4_defvalue = wxPyEmptyString ;
18627 wxString *arg4 = (wxString *) &arg4_defvalue ;
18628 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18629 wxFileConfig *result;
18630 bool temp1 = false ;
18631 bool temp2 = false ;
18632 bool temp3 = false ;
18633 bool temp4 = false ;
18634 PyObject * obj0 = 0 ;
18635 PyObject * obj1 = 0 ;
18636 PyObject * obj2 = 0 ;
18637 PyObject * obj3 = 0 ;
18638 PyObject * obj4 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18644 if (obj0) {
18645 {
18646 arg1 = wxString_in_helper(obj0);
18647 if (arg1 == NULL) SWIG_fail;
18648 temp1 = true;
18649 }
18650 }
18651 if (obj1) {
18652 {
18653 arg2 = wxString_in_helper(obj1);
18654 if (arg2 == NULL) SWIG_fail;
18655 temp2 = true;
18656 }
18657 }
18658 if (obj2) {
18659 {
18660 arg3 = wxString_in_helper(obj2);
18661 if (arg3 == NULL) SWIG_fail;
18662 temp3 = true;
18663 }
18664 }
18665 if (obj3) {
18666 {
18667 arg4 = wxString_in_helper(obj3);
18668 if (arg4 == NULL) SWIG_fail;
18669 temp4 = true;
18670 }
18671 }
18672 if (obj4) {
18673 {
18674 arg5 = (long)(SWIG_As_long(obj4));
18675 if (SWIG_arg_fail(5)) SWIG_fail;
18676 }
18677 }
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18686 {
18687 if (temp1)
18688 delete arg1;
18689 }
18690 {
18691 if (temp2)
18692 delete arg2;
18693 }
18694 {
18695 if (temp3)
18696 delete arg3;
18697 }
18698 {
18699 if (temp4)
18700 delete arg4;
18701 }
18702 return resultobj;
18703 fail:
18704 {
18705 if (temp1)
18706 delete arg1;
18707 }
18708 {
18709 if (temp2)
18710 delete arg2;
18711 }
18712 {
18713 if (temp3)
18714 delete arg3;
18715 }
18716 {
18717 if (temp4)
18718 delete arg4;
18719 }
18720 return NULL;
18721 }
18722
18723
18724 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18725 PyObject *resultobj;
18726 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18727 PyObject * obj0 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 {
18736 PyThreadState* __tstate = wxPyBeginAllowThreads();
18737 delete arg1;
18738
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 Py_INCREF(Py_None); resultobj = Py_None;
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18750 PyObject *obj;
18751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18752 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18753 Py_INCREF(obj);
18754 return Py_BuildValue((char *)"");
18755 }
18756 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18759 wxString *arg2 = 0 ;
18760 wxConfigPathChanger *result;
18761 bool temp2 = false ;
18762 PyObject * obj0 = 0 ;
18763 PyObject * obj1 = 0 ;
18764 char *kwnames[] = {
18765 (char *) "config",(char *) "entry", NULL
18766 };
18767
18768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18770 if (SWIG_arg_fail(1)) SWIG_fail;
18771 {
18772 arg2 = wxString_in_helper(obj1);
18773 if (arg2 == NULL) SWIG_fail;
18774 temp2 = true;
18775 }
18776 {
18777 PyThreadState* __tstate = wxPyBeginAllowThreads();
18778 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18779
18780 wxPyEndAllowThreads(__tstate);
18781 if (PyErr_Occurred()) SWIG_fail;
18782 }
18783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18784 {
18785 if (temp2)
18786 delete arg2;
18787 }
18788 return resultobj;
18789 fail:
18790 {
18791 if (temp2)
18792 delete arg2;
18793 }
18794 return NULL;
18795 }
18796
18797
18798 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj;
18800 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18801 PyObject * obj0 = 0 ;
18802 char *kwnames[] = {
18803 (char *) "self", NULL
18804 };
18805
18806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18808 if (SWIG_arg_fail(1)) SWIG_fail;
18809 {
18810 PyThreadState* __tstate = wxPyBeginAllowThreads();
18811 delete arg1;
18812
18813 wxPyEndAllowThreads(__tstate);
18814 if (PyErr_Occurred()) SWIG_fail;
18815 }
18816 Py_INCREF(Py_None); resultobj = Py_None;
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18826 wxString *result;
18827 PyObject * obj0 = 0 ;
18828 char *kwnames[] = {
18829 (char *) "self", NULL
18830 };
18831
18832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18834 if (SWIG_arg_fail(1)) SWIG_fail;
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 {
18838 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18839 result = (wxString *) &_result_ref;
18840 }
18841
18842 wxPyEndAllowThreads(__tstate);
18843 if (PyErr_Occurred()) SWIG_fail;
18844 }
18845 {
18846 #if wxUSE_UNICODE
18847 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18848 #else
18849 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18850 #endif
18851 }
18852 return resultobj;
18853 fail:
18854 return NULL;
18855 }
18856
18857
18858 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18859 PyObject *obj;
18860 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18861 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18862 Py_INCREF(obj);
18863 return Py_BuildValue((char *)"");
18864 }
18865 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj;
18867 wxString *arg1 = 0 ;
18868 wxString result;
18869 bool temp1 = false ;
18870 PyObject * obj0 = 0 ;
18871 char *kwnames[] = {
18872 (char *) "sz", NULL
18873 };
18874
18875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18876 {
18877 arg1 = wxString_in_helper(obj0);
18878 if (arg1 == NULL) SWIG_fail;
18879 temp1 = true;
18880 }
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 result = wxExpandEnvVars((wxString const &)*arg1);
18884
18885 wxPyEndAllowThreads(__tstate);
18886 if (PyErr_Occurred()) SWIG_fail;
18887 }
18888 {
18889 #if wxUSE_UNICODE
18890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18891 #else
18892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18893 #endif
18894 }
18895 {
18896 if (temp1)
18897 delete arg1;
18898 }
18899 return resultobj;
18900 fail:
18901 {
18902 if (temp1)
18903 delete arg1;
18904 }
18905 return NULL;
18906 }
18907
18908
18909 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18910 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18911 return 1;
18912 }
18913
18914
18915 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18916 PyObject *pyobj;
18917
18918 {
18919 #if wxUSE_UNICODE
18920 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18921 #else
18922 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18923 #endif
18924 }
18925 return pyobj;
18926 }
18927
18928
18929 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18930 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18931 return 1;
18932 }
18933
18934
18935 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18936 PyObject *pyobj;
18937
18938 {
18939 #if wxUSE_UNICODE
18940 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18941 #else
18942 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18943 #endif
18944 }
18945 return pyobj;
18946 }
18947
18948
18949 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18950 PyObject *resultobj;
18951 wxDateTime::Country arg1 ;
18952 PyObject * obj0 = 0 ;
18953 char *kwnames[] = {
18954 (char *) "country", NULL
18955 };
18956
18957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18958 {
18959 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 }
18962 {
18963 PyThreadState* __tstate = wxPyBeginAllowThreads();
18964 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18965
18966 wxPyEndAllowThreads(__tstate);
18967 if (PyErr_Occurred()) SWIG_fail;
18968 }
18969 Py_INCREF(Py_None); resultobj = Py_None;
18970 return resultobj;
18971 fail:
18972 return NULL;
18973 }
18974
18975
18976 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18977 PyObject *resultobj;
18978 wxDateTime::Country result;
18979 char *kwnames[] = {
18980 NULL
18981 };
18982
18983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18984 {
18985 PyThreadState* __tstate = wxPyBeginAllowThreads();
18986 result = (wxDateTime::Country)wxDateTime::GetCountry();
18987
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 resultobj = SWIG_From_int((result));
18992 return resultobj;
18993 fail:
18994 return NULL;
18995 }
18996
18997
18998 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18999 PyObject *resultobj;
19000 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19001 bool result;
19002 PyObject * obj0 = 0 ;
19003 char *kwnames[] = {
19004 (char *) "country", NULL
19005 };
19006
19007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19008 if (obj0) {
19009 {
19010 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19011 if (SWIG_arg_fail(1)) SWIG_fail;
19012 }
19013 }
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19017
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 {
19022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19023 }
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj;
19032 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19033 int result;
19034 PyObject * obj0 = 0 ;
19035 char *kwnames[] = {
19036 (char *) "cal", NULL
19037 };
19038
19039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19040 if (obj0) {
19041 {
19042 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 }
19045 }
19046 {
19047 PyThreadState* __tstate = wxPyBeginAllowThreads();
19048 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19049
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 {
19054 resultobj = SWIG_From_int((int)(result));
19055 }
19056 return resultobj;
19057 fail:
19058 return NULL;
19059 }
19060
19061
19062 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19063 PyObject *resultobj;
19064 int arg1 ;
19065 int result;
19066 PyObject * obj0 = 0 ;
19067 char *kwnames[] = {
19068 (char *) "year", NULL
19069 };
19070
19071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19072 {
19073 arg1 = (int)(SWIG_As_int(obj0));
19074 if (SWIG_arg_fail(1)) SWIG_fail;
19075 }
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 result = (int)wxDateTime::ConvertYearToBC(arg1);
19079
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 {
19084 resultobj = SWIG_From_int((int)(result));
19085 }
19086 return resultobj;
19087 fail:
19088 return NULL;
19089 }
19090
19091
19092 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19093 PyObject *resultobj;
19094 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19095 wxDateTime::Month result;
19096 PyObject * obj0 = 0 ;
19097 char *kwnames[] = {
19098 (char *) "cal", NULL
19099 };
19100
19101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19102 if (obj0) {
19103 {
19104 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19105 if (SWIG_arg_fail(1)) SWIG_fail;
19106 }
19107 }
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19111
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 resultobj = SWIG_From_int((result));
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 int arg1 = (int) wxDateTime::Inv_Year ;
19125 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19126 bool result;
19127 PyObject * obj0 = 0 ;
19128 PyObject * obj1 = 0 ;
19129 char *kwnames[] = {
19130 (char *) "year",(char *) "cal", NULL
19131 };
19132
19133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19134 if (obj0) {
19135 {
19136 arg1 = (int)(SWIG_As_int(obj0));
19137 if (SWIG_arg_fail(1)) SWIG_fail;
19138 }
19139 }
19140 if (obj1) {
19141 {
19142 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19143 if (SWIG_arg_fail(2)) SWIG_fail;
19144 }
19145 }
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19149
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 {
19154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19155 }
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj;
19164 int arg1 = (int) wxDateTime::Inv_Year ;
19165 int result;
19166 PyObject * obj0 = 0 ;
19167 char *kwnames[] = {
19168 (char *) "year", NULL
19169 };
19170
19171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19172 if (obj0) {
19173 {
19174 arg1 = (int)(SWIG_As_int(obj0));
19175 if (SWIG_arg_fail(1)) SWIG_fail;
19176 }
19177 }
19178 {
19179 PyThreadState* __tstate = wxPyBeginAllowThreads();
19180 result = (int)wxDateTime::GetCentury(arg1);
19181
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 {
19186 resultobj = SWIG_From_int((int)(result));
19187 }
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19195 PyObject *resultobj;
19196 int arg1 ;
19197 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19198 int result;
19199 PyObject * obj0 = 0 ;
19200 PyObject * obj1 = 0 ;
19201 char *kwnames[] = {
19202 (char *) "year",(char *) "cal", NULL
19203 };
19204
19205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19206 {
19207 arg1 = (int)(SWIG_As_int(obj0));
19208 if (SWIG_arg_fail(1)) SWIG_fail;
19209 }
19210 if (obj1) {
19211 {
19212 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19213 if (SWIG_arg_fail(2)) SWIG_fail;
19214 }
19215 }
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19219
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 {
19224 resultobj = SWIG_From_int((int)(result));
19225 }
19226 return resultobj;
19227 fail:
19228 return NULL;
19229 }
19230
19231
19232 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj;
19234 wxDateTime::Month arg1 ;
19235 int arg2 = (int) wxDateTime::Inv_Year ;
19236 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19237 int result;
19238 PyObject * obj0 = 0 ;
19239 PyObject * obj1 = 0 ;
19240 PyObject * obj2 = 0 ;
19241 char *kwnames[] = {
19242 (char *) "month",(char *) "year",(char *) "cal", NULL
19243 };
19244
19245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19246 {
19247 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19248 if (SWIG_arg_fail(1)) SWIG_fail;
19249 }
19250 if (obj1) {
19251 {
19252 arg2 = (int)(SWIG_As_int(obj1));
19253 if (SWIG_arg_fail(2)) SWIG_fail;
19254 }
19255 }
19256 if (obj2) {
19257 {
19258 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19259 if (SWIG_arg_fail(3)) SWIG_fail;
19260 }
19261 }
19262 {
19263 PyThreadState* __tstate = wxPyBeginAllowThreads();
19264 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19265
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = SWIG_From_int((int)(result));
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 wxDateTime::Month arg1 ;
19281 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19282 wxString result;
19283 PyObject * obj0 = 0 ;
19284 PyObject * obj1 = 0 ;
19285 char *kwnames[] = {
19286 (char *) "month",(char *) "flags", NULL
19287 };
19288
19289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19290 {
19291 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19292 if (SWIG_arg_fail(1)) SWIG_fail;
19293 }
19294 if (obj1) {
19295 {
19296 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19297 if (SWIG_arg_fail(2)) SWIG_fail;
19298 }
19299 }
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19303
19304 wxPyEndAllowThreads(__tstate);
19305 if (PyErr_Occurred()) SWIG_fail;
19306 }
19307 {
19308 #if wxUSE_UNICODE
19309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19310 #else
19311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19312 #endif
19313 }
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj;
19322 wxDateTime::WeekDay arg1 ;
19323 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19324 wxString result;
19325 PyObject * obj0 = 0 ;
19326 PyObject * obj1 = 0 ;
19327 char *kwnames[] = {
19328 (char *) "weekday",(char *) "flags", NULL
19329 };
19330
19331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19332 {
19333 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19334 if (SWIG_arg_fail(1)) SWIG_fail;
19335 }
19336 if (obj1) {
19337 {
19338 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19339 if (SWIG_arg_fail(2)) SWIG_fail;
19340 }
19341 }
19342 {
19343 PyThreadState* __tstate = wxPyBeginAllowThreads();
19344 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19345
19346 wxPyEndAllowThreads(__tstate);
19347 if (PyErr_Occurred()) SWIG_fail;
19348 }
19349 {
19350 #if wxUSE_UNICODE
19351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19352 #else
19353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19354 #endif
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 PyObject *result;
19365 char *kwnames[] = {
19366 NULL
19367 };
19368
19369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19370 {
19371 PyThreadState* __tstate = wxPyBeginAllowThreads();
19372 result = (PyObject *)DateTime_GetAmPmStrings();
19373
19374 wxPyEndAllowThreads(__tstate);
19375 if (PyErr_Occurred()) SWIG_fail;
19376 }
19377 resultobj = result;
19378 return resultobj;
19379 fail:
19380 return NULL;
19381 }
19382
19383
19384 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19385 PyObject *resultobj;
19386 int arg1 = (int) wxDateTime::Inv_Year ;
19387 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19388 bool result;
19389 PyObject * obj0 = 0 ;
19390 PyObject * obj1 = 0 ;
19391 char *kwnames[] = {
19392 (char *) "year",(char *) "country", NULL
19393 };
19394
19395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19396 if (obj0) {
19397 {
19398 arg1 = (int)(SWIG_As_int(obj0));
19399 if (SWIG_arg_fail(1)) SWIG_fail;
19400 }
19401 }
19402 if (obj1) {
19403 {
19404 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19405 if (SWIG_arg_fail(2)) SWIG_fail;
19406 }
19407 }
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19411
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 {
19416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19417 }
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19425 PyObject *resultobj;
19426 int arg1 = (int) wxDateTime::Inv_Year ;
19427 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19428 wxDateTime result;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "year",(char *) "country", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19436 if (obj0) {
19437 {
19438 arg1 = (int)(SWIG_As_int(obj0));
19439 if (SWIG_arg_fail(1)) SWIG_fail;
19440 }
19441 }
19442 if (obj1) {
19443 {
19444 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19445 if (SWIG_arg_fail(2)) SWIG_fail;
19446 }
19447 }
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19451
19452 wxPyEndAllowThreads(__tstate);
19453 if (PyErr_Occurred()) SWIG_fail;
19454 }
19455 {
19456 wxDateTime * resultptr;
19457 resultptr = new wxDateTime((wxDateTime &)(result));
19458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19459 }
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj;
19468 int arg1 = (int) wxDateTime::Inv_Year ;
19469 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19470 wxDateTime result;
19471 PyObject * obj0 = 0 ;
19472 PyObject * obj1 = 0 ;
19473 char *kwnames[] = {
19474 (char *) "year",(char *) "country", NULL
19475 };
19476
19477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19478 if (obj0) {
19479 {
19480 arg1 = (int)(SWIG_As_int(obj0));
19481 if (SWIG_arg_fail(1)) SWIG_fail;
19482 }
19483 }
19484 if (obj1) {
19485 {
19486 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19487 if (SWIG_arg_fail(2)) SWIG_fail;
19488 }
19489 }
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19493
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 {
19498 wxDateTime * resultptr;
19499 resultptr = new wxDateTime((wxDateTime &)(result));
19500 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19501 }
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19509 PyObject *resultobj;
19510 wxDateTime result;
19511 char *kwnames[] = {
19512 NULL
19513 };
19514
19515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 result = wxDateTime::Now();
19519
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 {
19524 wxDateTime * resultptr;
19525 resultptr = new wxDateTime((wxDateTime &)(result));
19526 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19527 }
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19535 PyObject *resultobj;
19536 wxDateTime result;
19537 char *kwnames[] = {
19538 NULL
19539 };
19540
19541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = wxDateTime::UNow();
19545
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 {
19550 wxDateTime * resultptr;
19551 resultptr = new wxDateTime((wxDateTime &)(result));
19552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19553 }
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19561 PyObject *resultobj;
19562 wxDateTime result;
19563 char *kwnames[] = {
19564 NULL
19565 };
19566
19567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = wxDateTime::Today();
19571
19572 wxPyEndAllowThreads(__tstate);
19573 if (PyErr_Occurred()) SWIG_fail;
19574 }
19575 {
19576 wxDateTime * resultptr;
19577 resultptr = new wxDateTime((wxDateTime &)(result));
19578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19579 }
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19587 PyObject *resultobj;
19588 wxDateTime *result;
19589 char *kwnames[] = {
19590 NULL
19591 };
19592
19593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19594 {
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 result = (wxDateTime *)new wxDateTime();
19597
19598 wxPyEndAllowThreads(__tstate);
19599 if (PyErr_Occurred()) SWIG_fail;
19600 }
19601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19602 return resultobj;
19603 fail:
19604 return NULL;
19605 }
19606
19607
19608 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19609 PyObject *resultobj;
19610 time_t arg1 ;
19611 wxDateTime *result;
19612 PyObject * obj0 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "timet", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19618 {
19619 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19620 if (SWIG_arg_fail(1)) SWIG_fail;
19621 }
19622 {
19623 PyThreadState* __tstate = wxPyBeginAllowThreads();
19624 result = (wxDateTime *)new wxDateTime(arg1);
19625
19626 wxPyEndAllowThreads(__tstate);
19627 if (PyErr_Occurred()) SWIG_fail;
19628 }
19629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj;
19638 double arg1 ;
19639 wxDateTime *result;
19640 PyObject * obj0 = 0 ;
19641 char *kwnames[] = {
19642 (char *) "jdn", NULL
19643 };
19644
19645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19646 {
19647 arg1 = (double)(SWIG_As_double(obj0));
19648 if (SWIG_arg_fail(1)) SWIG_fail;
19649 }
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 result = (wxDateTime *)new wxDateTime(arg1);
19653
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj;
19666 int arg1 ;
19667 int arg2 = (int) 0 ;
19668 int arg3 = (int) 0 ;
19669 int arg4 = (int) 0 ;
19670 wxDateTime *result;
19671 PyObject * obj0 = 0 ;
19672 PyObject * obj1 = 0 ;
19673 PyObject * obj2 = 0 ;
19674 PyObject * obj3 = 0 ;
19675 char *kwnames[] = {
19676 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19677 };
19678
19679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19680 {
19681 arg1 = (int)(SWIG_As_int(obj0));
19682 if (SWIG_arg_fail(1)) SWIG_fail;
19683 }
19684 if (obj1) {
19685 {
19686 arg2 = (int)(SWIG_As_int(obj1));
19687 if (SWIG_arg_fail(2)) SWIG_fail;
19688 }
19689 }
19690 if (obj2) {
19691 {
19692 arg3 = (int)(SWIG_As_int(obj2));
19693 if (SWIG_arg_fail(3)) SWIG_fail;
19694 }
19695 }
19696 if (obj3) {
19697 {
19698 arg4 = (int)(SWIG_As_int(obj3));
19699 if (SWIG_arg_fail(4)) SWIG_fail;
19700 }
19701 }
19702 {
19703 PyThreadState* __tstate = wxPyBeginAllowThreads();
19704 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19705
19706 wxPyEndAllowThreads(__tstate);
19707 if (PyErr_Occurred()) SWIG_fail;
19708 }
19709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19710 return resultobj;
19711 fail:
19712 return NULL;
19713 }
19714
19715
19716 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19717 PyObject *resultobj;
19718 int arg1 ;
19719 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19720 int arg3 = (int) wxDateTime::Inv_Year ;
19721 int arg4 = (int) 0 ;
19722 int arg5 = (int) 0 ;
19723 int arg6 = (int) 0 ;
19724 int arg7 = (int) 0 ;
19725 wxDateTime *result;
19726 PyObject * obj0 = 0 ;
19727 PyObject * obj1 = 0 ;
19728 PyObject * obj2 = 0 ;
19729 PyObject * obj3 = 0 ;
19730 PyObject * obj4 = 0 ;
19731 PyObject * obj5 = 0 ;
19732 PyObject * obj6 = 0 ;
19733 char *kwnames[] = {
19734 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19735 };
19736
19737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19738 {
19739 arg1 = (int)(SWIG_As_int(obj0));
19740 if (SWIG_arg_fail(1)) SWIG_fail;
19741 }
19742 if (obj1) {
19743 {
19744 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19745 if (SWIG_arg_fail(2)) SWIG_fail;
19746 }
19747 }
19748 if (obj2) {
19749 {
19750 arg3 = (int)(SWIG_As_int(obj2));
19751 if (SWIG_arg_fail(3)) SWIG_fail;
19752 }
19753 }
19754 if (obj3) {
19755 {
19756 arg4 = (int)(SWIG_As_int(obj3));
19757 if (SWIG_arg_fail(4)) SWIG_fail;
19758 }
19759 }
19760 if (obj4) {
19761 {
19762 arg5 = (int)(SWIG_As_int(obj4));
19763 if (SWIG_arg_fail(5)) SWIG_fail;
19764 }
19765 }
19766 if (obj5) {
19767 {
19768 arg6 = (int)(SWIG_As_int(obj5));
19769 if (SWIG_arg_fail(6)) SWIG_fail;
19770 }
19771 }
19772 if (obj6) {
19773 {
19774 arg7 = (int)(SWIG_As_int(obj6));
19775 if (SWIG_arg_fail(7)) SWIG_fail;
19776 }
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19781
19782 wxPyEndAllowThreads(__tstate);
19783 if (PyErr_Occurred()) SWIG_fail;
19784 }
19785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19786 return resultobj;
19787 fail:
19788 return NULL;
19789 }
19790
19791
19792 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19793 PyObject *resultobj;
19794 wxDateTime *arg1 = (wxDateTime *) 0 ;
19795 PyObject * obj0 = 0 ;
19796 char *kwnames[] = {
19797 (char *) "self", NULL
19798 };
19799
19800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19802 if (SWIG_arg_fail(1)) SWIG_fail;
19803 {
19804 PyThreadState* __tstate = wxPyBeginAllowThreads();
19805 delete arg1;
19806
19807 wxPyEndAllowThreads(__tstate);
19808 if (PyErr_Occurred()) SWIG_fail;
19809 }
19810 Py_INCREF(Py_None); resultobj = Py_None;
19811 return resultobj;
19812 fail:
19813 return NULL;
19814 }
19815
19816
19817 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19818 PyObject *resultobj;
19819 wxDateTime *arg1 = (wxDateTime *) 0 ;
19820 wxDateTime *result;
19821 PyObject * obj0 = 0 ;
19822 char *kwnames[] = {
19823 (char *) "self", NULL
19824 };
19825
19826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19828 if (SWIG_arg_fail(1)) SWIG_fail;
19829 {
19830 PyThreadState* __tstate = wxPyBeginAllowThreads();
19831 {
19832 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19833 result = (wxDateTime *) &_result_ref;
19834 }
19835
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19840 return resultobj;
19841 fail:
19842 return NULL;
19843 }
19844
19845
19846 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19847 PyObject *resultobj;
19848 wxDateTime *arg1 = (wxDateTime *) 0 ;
19849 time_t arg2 ;
19850 wxDateTime *result;
19851 PyObject * obj0 = 0 ;
19852 PyObject * obj1 = 0 ;
19853 char *kwnames[] = {
19854 (char *) "self",(char *) "timet", NULL
19855 };
19856
19857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19859 if (SWIG_arg_fail(1)) SWIG_fail;
19860 {
19861 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19862 if (SWIG_arg_fail(2)) SWIG_fail;
19863 }
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 {
19867 wxDateTime &_result_ref = (arg1)->Set(arg2);
19868 result = (wxDateTime *) &_result_ref;
19869 }
19870
19871 wxPyEndAllowThreads(__tstate);
19872 if (PyErr_Occurred()) SWIG_fail;
19873 }
19874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj;
19883 wxDateTime *arg1 = (wxDateTime *) 0 ;
19884 double arg2 ;
19885 wxDateTime *result;
19886 PyObject * obj0 = 0 ;
19887 PyObject * obj1 = 0 ;
19888 char *kwnames[] = {
19889 (char *) "self",(char *) "jdn", NULL
19890 };
19891
19892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19894 if (SWIG_arg_fail(1)) SWIG_fail;
19895 {
19896 arg2 = (double)(SWIG_As_double(obj1));
19897 if (SWIG_arg_fail(2)) SWIG_fail;
19898 }
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 {
19902 wxDateTime &_result_ref = (arg1)->Set(arg2);
19903 result = (wxDateTime *) &_result_ref;
19904 }
19905
19906 wxPyEndAllowThreads(__tstate);
19907 if (PyErr_Occurred()) SWIG_fail;
19908 }
19909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19917 PyObject *resultobj;
19918 wxDateTime *arg1 = (wxDateTime *) 0 ;
19919 int arg2 ;
19920 int arg3 = (int) 0 ;
19921 int arg4 = (int) 0 ;
19922 int arg5 = (int) 0 ;
19923 wxDateTime *result;
19924 PyObject * obj0 = 0 ;
19925 PyObject * obj1 = 0 ;
19926 PyObject * obj2 = 0 ;
19927 PyObject * obj3 = 0 ;
19928 PyObject * obj4 = 0 ;
19929 char *kwnames[] = {
19930 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19931 };
19932
19933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19935 if (SWIG_arg_fail(1)) SWIG_fail;
19936 {
19937 arg2 = (int)(SWIG_As_int(obj1));
19938 if (SWIG_arg_fail(2)) SWIG_fail;
19939 }
19940 if (obj2) {
19941 {
19942 arg3 = (int)(SWIG_As_int(obj2));
19943 if (SWIG_arg_fail(3)) SWIG_fail;
19944 }
19945 }
19946 if (obj3) {
19947 {
19948 arg4 = (int)(SWIG_As_int(obj3));
19949 if (SWIG_arg_fail(4)) SWIG_fail;
19950 }
19951 }
19952 if (obj4) {
19953 {
19954 arg5 = (int)(SWIG_As_int(obj4));
19955 if (SWIG_arg_fail(5)) SWIG_fail;
19956 }
19957 }
19958 {
19959 PyThreadState* __tstate = wxPyBeginAllowThreads();
19960 {
19961 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19962 result = (wxDateTime *) &_result_ref;
19963 }
19964
19965 wxPyEndAllowThreads(__tstate);
19966 if (PyErr_Occurred()) SWIG_fail;
19967 }
19968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19969 return resultobj;
19970 fail:
19971 return NULL;
19972 }
19973
19974
19975 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19976 PyObject *resultobj;
19977 wxDateTime *arg1 = (wxDateTime *) 0 ;
19978 int arg2 ;
19979 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19980 int arg4 = (int) wxDateTime::Inv_Year ;
19981 int arg5 = (int) 0 ;
19982 int arg6 = (int) 0 ;
19983 int arg7 = (int) 0 ;
19984 int arg8 = (int) 0 ;
19985 wxDateTime *result;
19986 PyObject * obj0 = 0 ;
19987 PyObject * obj1 = 0 ;
19988 PyObject * obj2 = 0 ;
19989 PyObject * obj3 = 0 ;
19990 PyObject * obj4 = 0 ;
19991 PyObject * obj5 = 0 ;
19992 PyObject * obj6 = 0 ;
19993 PyObject * obj7 = 0 ;
19994 char *kwnames[] = {
19995 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19996 };
19997
19998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20000 if (SWIG_arg_fail(1)) SWIG_fail;
20001 {
20002 arg2 = (int)(SWIG_As_int(obj1));
20003 if (SWIG_arg_fail(2)) SWIG_fail;
20004 }
20005 if (obj2) {
20006 {
20007 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20008 if (SWIG_arg_fail(3)) SWIG_fail;
20009 }
20010 }
20011 if (obj3) {
20012 {
20013 arg4 = (int)(SWIG_As_int(obj3));
20014 if (SWIG_arg_fail(4)) SWIG_fail;
20015 }
20016 }
20017 if (obj4) {
20018 {
20019 arg5 = (int)(SWIG_As_int(obj4));
20020 if (SWIG_arg_fail(5)) SWIG_fail;
20021 }
20022 }
20023 if (obj5) {
20024 {
20025 arg6 = (int)(SWIG_As_int(obj5));
20026 if (SWIG_arg_fail(6)) SWIG_fail;
20027 }
20028 }
20029 if (obj6) {
20030 {
20031 arg7 = (int)(SWIG_As_int(obj6));
20032 if (SWIG_arg_fail(7)) SWIG_fail;
20033 }
20034 }
20035 if (obj7) {
20036 {
20037 arg8 = (int)(SWIG_As_int(obj7));
20038 if (SWIG_arg_fail(8)) SWIG_fail;
20039 }
20040 }
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 {
20044 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20045 result = (wxDateTime *) &_result_ref;
20046 }
20047
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20059 PyObject *resultobj;
20060 wxDateTime *arg1 = (wxDateTime *) 0 ;
20061 wxDateTime *result;
20062 PyObject * obj0 = 0 ;
20063 char *kwnames[] = {
20064 (char *) "self", NULL
20065 };
20066
20067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20069 if (SWIG_arg_fail(1)) SWIG_fail;
20070 {
20071 PyThreadState* __tstate = wxPyBeginAllowThreads();
20072 {
20073 wxDateTime &_result_ref = (arg1)->ResetTime();
20074 result = (wxDateTime *) &_result_ref;
20075 }
20076
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20081 return resultobj;
20082 fail:
20083 return NULL;
20084 }
20085
20086
20087 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20088 PyObject *resultobj;
20089 wxDateTime *arg1 = (wxDateTime *) 0 ;
20090 int arg2 ;
20091 wxDateTime *result;
20092 PyObject * obj0 = 0 ;
20093 PyObject * obj1 = 0 ;
20094 char *kwnames[] = {
20095 (char *) "self",(char *) "year", NULL
20096 };
20097
20098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20100 if (SWIG_arg_fail(1)) SWIG_fail;
20101 {
20102 arg2 = (int)(SWIG_As_int(obj1));
20103 if (SWIG_arg_fail(2)) SWIG_fail;
20104 }
20105 {
20106 PyThreadState* __tstate = wxPyBeginAllowThreads();
20107 {
20108 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20109 result = (wxDateTime *) &_result_ref;
20110 }
20111
20112 wxPyEndAllowThreads(__tstate);
20113 if (PyErr_Occurred()) SWIG_fail;
20114 }
20115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20116 return resultobj;
20117 fail:
20118 return NULL;
20119 }
20120
20121
20122 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20123 PyObject *resultobj;
20124 wxDateTime *arg1 = (wxDateTime *) 0 ;
20125 wxDateTime::Month arg2 ;
20126 wxDateTime *result;
20127 PyObject * obj0 = 0 ;
20128 PyObject * obj1 = 0 ;
20129 char *kwnames[] = {
20130 (char *) "self",(char *) "month", NULL
20131 };
20132
20133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20135 if (SWIG_arg_fail(1)) SWIG_fail;
20136 {
20137 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20138 if (SWIG_arg_fail(2)) SWIG_fail;
20139 }
20140 {
20141 PyThreadState* __tstate = wxPyBeginAllowThreads();
20142 {
20143 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20144 result = (wxDateTime *) &_result_ref;
20145 }
20146
20147 wxPyEndAllowThreads(__tstate);
20148 if (PyErr_Occurred()) SWIG_fail;
20149 }
20150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20151 return resultobj;
20152 fail:
20153 return NULL;
20154 }
20155
20156
20157 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20158 PyObject *resultobj;
20159 wxDateTime *arg1 = (wxDateTime *) 0 ;
20160 int arg2 ;
20161 wxDateTime *result;
20162 PyObject * obj0 = 0 ;
20163 PyObject * obj1 = 0 ;
20164 char *kwnames[] = {
20165 (char *) "self",(char *) "day", NULL
20166 };
20167
20168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20170 if (SWIG_arg_fail(1)) SWIG_fail;
20171 {
20172 arg2 = (int)(SWIG_As_int(obj1));
20173 if (SWIG_arg_fail(2)) SWIG_fail;
20174 }
20175 {
20176 PyThreadState* __tstate = wxPyBeginAllowThreads();
20177 {
20178 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20179 result = (wxDateTime *) &_result_ref;
20180 }
20181
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20186 return resultobj;
20187 fail:
20188 return NULL;
20189 }
20190
20191
20192 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20193 PyObject *resultobj;
20194 wxDateTime *arg1 = (wxDateTime *) 0 ;
20195 int arg2 ;
20196 wxDateTime *result;
20197 PyObject * obj0 = 0 ;
20198 PyObject * obj1 = 0 ;
20199 char *kwnames[] = {
20200 (char *) "self",(char *) "hour", NULL
20201 };
20202
20203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20205 if (SWIG_arg_fail(1)) SWIG_fail;
20206 {
20207 arg2 = (int)(SWIG_As_int(obj1));
20208 if (SWIG_arg_fail(2)) SWIG_fail;
20209 }
20210 {
20211 PyThreadState* __tstate = wxPyBeginAllowThreads();
20212 {
20213 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20214 result = (wxDateTime *) &_result_ref;
20215 }
20216
20217 wxPyEndAllowThreads(__tstate);
20218 if (PyErr_Occurred()) SWIG_fail;
20219 }
20220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20221 return resultobj;
20222 fail:
20223 return NULL;
20224 }
20225
20226
20227 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20228 PyObject *resultobj;
20229 wxDateTime *arg1 = (wxDateTime *) 0 ;
20230 int arg2 ;
20231 wxDateTime *result;
20232 PyObject * obj0 = 0 ;
20233 PyObject * obj1 = 0 ;
20234 char *kwnames[] = {
20235 (char *) "self",(char *) "minute", NULL
20236 };
20237
20238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20240 if (SWIG_arg_fail(1)) SWIG_fail;
20241 {
20242 arg2 = (int)(SWIG_As_int(obj1));
20243 if (SWIG_arg_fail(2)) SWIG_fail;
20244 }
20245 {
20246 PyThreadState* __tstate = wxPyBeginAllowThreads();
20247 {
20248 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20249 result = (wxDateTime *) &_result_ref;
20250 }
20251
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20263 PyObject *resultobj;
20264 wxDateTime *arg1 = (wxDateTime *) 0 ;
20265 int arg2 ;
20266 wxDateTime *result;
20267 PyObject * obj0 = 0 ;
20268 PyObject * obj1 = 0 ;
20269 char *kwnames[] = {
20270 (char *) "self",(char *) "second", NULL
20271 };
20272
20273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20275 if (SWIG_arg_fail(1)) SWIG_fail;
20276 {
20277 arg2 = (int)(SWIG_As_int(obj1));
20278 if (SWIG_arg_fail(2)) SWIG_fail;
20279 }
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 {
20283 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20284 result = (wxDateTime *) &_result_ref;
20285 }
20286
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj;
20299 wxDateTime *arg1 = (wxDateTime *) 0 ;
20300 int arg2 ;
20301 wxDateTime *result;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "self",(char *) "millisecond", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20310 if (SWIG_arg_fail(1)) SWIG_fail;
20311 {
20312 arg2 = (int)(SWIG_As_int(obj1));
20313 if (SWIG_arg_fail(2)) SWIG_fail;
20314 }
20315 {
20316 PyThreadState* __tstate = wxPyBeginAllowThreads();
20317 {
20318 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20319 result = (wxDateTime *) &_result_ref;
20320 }
20321
20322 wxPyEndAllowThreads(__tstate);
20323 if (PyErr_Occurred()) SWIG_fail;
20324 }
20325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20333 PyObject *resultobj;
20334 wxDateTime *arg1 = (wxDateTime *) 0 ;
20335 wxDateTime::WeekDay arg2 ;
20336 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20337 wxDateTime *result;
20338 PyObject * obj0 = 0 ;
20339 PyObject * obj1 = 0 ;
20340 PyObject * obj2 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20350 if (SWIG_arg_fail(2)) SWIG_fail;
20351 }
20352 if (obj2) {
20353 {
20354 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20355 if (SWIG_arg_fail(3)) SWIG_fail;
20356 }
20357 }
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 {
20361 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20362 result = (wxDateTime *) &_result_ref;
20363 }
20364
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20376 PyObject *resultobj;
20377 wxDateTime *arg1 = (wxDateTime *) 0 ;
20378 wxDateTime::WeekDay arg2 ;
20379 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20380 wxDateTime result;
20381 PyObject * obj0 = 0 ;
20382 PyObject * obj1 = 0 ;
20383 PyObject * obj2 = 0 ;
20384 char *kwnames[] = {
20385 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20386 };
20387
20388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20390 if (SWIG_arg_fail(1)) SWIG_fail;
20391 {
20392 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20393 if (SWIG_arg_fail(2)) SWIG_fail;
20394 }
20395 if (obj2) {
20396 {
20397 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20398 if (SWIG_arg_fail(3)) SWIG_fail;
20399 }
20400 }
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20404
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 {
20409 wxDateTime * resultptr;
20410 resultptr = new wxDateTime((wxDateTime &)(result));
20411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20412 }
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20420 PyObject *resultobj;
20421 wxDateTime *arg1 = (wxDateTime *) 0 ;
20422 wxDateTime::WeekDay arg2 ;
20423 wxDateTime *result;
20424 PyObject * obj0 = 0 ;
20425 PyObject * obj1 = 0 ;
20426 char *kwnames[] = {
20427 (char *) "self",(char *) "weekday", NULL
20428 };
20429
20430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20432 if (SWIG_arg_fail(1)) SWIG_fail;
20433 {
20434 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20435 if (SWIG_arg_fail(2)) SWIG_fail;
20436 }
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 {
20440 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20441 result = (wxDateTime *) &_result_ref;
20442 }
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20448 return resultobj;
20449 fail:
20450 return NULL;
20451 }
20452
20453
20454 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20455 PyObject *resultobj;
20456 wxDateTime *arg1 = (wxDateTime *) 0 ;
20457 wxDateTime::WeekDay arg2 ;
20458 wxDateTime result;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self",(char *) "weekday", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20470 if (SWIG_arg_fail(2)) SWIG_fail;
20471 }
20472 {
20473 PyThreadState* __tstate = wxPyBeginAllowThreads();
20474 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20475
20476 wxPyEndAllowThreads(__tstate);
20477 if (PyErr_Occurred()) SWIG_fail;
20478 }
20479 {
20480 wxDateTime * resultptr;
20481 resultptr = new wxDateTime((wxDateTime &)(result));
20482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20483 }
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj;
20492 wxDateTime *arg1 = (wxDateTime *) 0 ;
20493 wxDateTime::WeekDay arg2 ;
20494 wxDateTime *result;
20495 PyObject * obj0 = 0 ;
20496 PyObject * obj1 = 0 ;
20497 char *kwnames[] = {
20498 (char *) "self",(char *) "weekday", NULL
20499 };
20500
20501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",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 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20506 if (SWIG_arg_fail(2)) SWIG_fail;
20507 }
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 {
20511 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )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_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj;
20527 wxDateTime *arg1 = (wxDateTime *) 0 ;
20528 wxDateTime::WeekDay arg2 ;
20529 wxDateTime result;
20530 PyObject * obj0 = 0 ;
20531 PyObject * obj1 = 0 ;
20532 char *kwnames[] = {
20533 (char *) "self",(char *) "weekday", NULL
20534 };
20535
20536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",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 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20541 if (SWIG_arg_fail(2)) SWIG_fail;
20542 }
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20546
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 {
20551 wxDateTime * resultptr;
20552 resultptr = new wxDateTime((wxDateTime &)(result));
20553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20554 }
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20562 PyObject *resultobj;
20563 wxDateTime *arg1 = (wxDateTime *) 0 ;
20564 wxDateTime::WeekDay arg2 ;
20565 int arg3 = (int) 1 ;
20566 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20567 int arg5 = (int) wxDateTime::Inv_Year ;
20568 bool result;
20569 PyObject * obj0 = 0 ;
20570 PyObject * obj1 = 0 ;
20571 PyObject * obj2 = 0 ;
20572 PyObject * obj3 = 0 ;
20573 PyObject * obj4 = 0 ;
20574 char *kwnames[] = {
20575 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20576 };
20577
20578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20580 if (SWIG_arg_fail(1)) SWIG_fail;
20581 {
20582 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20583 if (SWIG_arg_fail(2)) SWIG_fail;
20584 }
20585 if (obj2) {
20586 {
20587 arg3 = (int)(SWIG_As_int(obj2));
20588 if (SWIG_arg_fail(3)) SWIG_fail;
20589 }
20590 }
20591 if (obj3) {
20592 {
20593 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20594 if (SWIG_arg_fail(4)) SWIG_fail;
20595 }
20596 }
20597 if (obj4) {
20598 {
20599 arg5 = (int)(SWIG_As_int(obj4));
20600 if (SWIG_arg_fail(5)) SWIG_fail;
20601 }
20602 }
20603 {
20604 PyThreadState* __tstate = wxPyBeginAllowThreads();
20605 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20606
20607 wxPyEndAllowThreads(__tstate);
20608 if (PyErr_Occurred()) SWIG_fail;
20609 }
20610 {
20611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20612 }
20613 return resultobj;
20614 fail:
20615 return NULL;
20616 }
20617
20618
20619 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj;
20621 wxDateTime *arg1 = (wxDateTime *) 0 ;
20622 wxDateTime::WeekDay arg2 ;
20623 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20624 int arg4 = (int) wxDateTime::Inv_Year ;
20625 bool result;
20626 PyObject * obj0 = 0 ;
20627 PyObject * obj1 = 0 ;
20628 PyObject * obj2 = 0 ;
20629 PyObject * obj3 = 0 ;
20630 char *kwnames[] = {
20631 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20632 };
20633
20634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20636 if (SWIG_arg_fail(1)) SWIG_fail;
20637 {
20638 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20639 if (SWIG_arg_fail(2)) SWIG_fail;
20640 }
20641 if (obj2) {
20642 {
20643 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20644 if (SWIG_arg_fail(3)) SWIG_fail;
20645 }
20646 }
20647 if (obj3) {
20648 {
20649 arg4 = (int)(SWIG_As_int(obj3));
20650 if (SWIG_arg_fail(4)) SWIG_fail;
20651 }
20652 }
20653 {
20654 PyThreadState* __tstate = wxPyBeginAllowThreads();
20655 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20656
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 {
20661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20662 }
20663 return resultobj;
20664 fail:
20665 return NULL;
20666 }
20667
20668
20669 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20670 PyObject *resultobj;
20671 wxDateTime *arg1 = (wxDateTime *) 0 ;
20672 wxDateTime::WeekDay arg2 ;
20673 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20674 int arg4 = (int) wxDateTime::Inv_Year ;
20675 wxDateTime result;
20676 PyObject * obj0 = 0 ;
20677 PyObject * obj1 = 0 ;
20678 PyObject * obj2 = 0 ;
20679 PyObject * obj3 = 0 ;
20680 char *kwnames[] = {
20681 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20682 };
20683
20684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20686 if (SWIG_arg_fail(1)) SWIG_fail;
20687 {
20688 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20689 if (SWIG_arg_fail(2)) SWIG_fail;
20690 }
20691 if (obj2) {
20692 {
20693 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20694 if (SWIG_arg_fail(3)) SWIG_fail;
20695 }
20696 }
20697 if (obj3) {
20698 {
20699 arg4 = (int)(SWIG_As_int(obj3));
20700 if (SWIG_arg_fail(4)) SWIG_fail;
20701 }
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20706
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 {
20711 wxDateTime * resultptr;
20712 resultptr = new wxDateTime((wxDateTime &)(result));
20713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20714 }
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20722 PyObject *resultobj;
20723 wxDateTime *arg1 = (wxDateTime *) 0 ;
20724 int arg2 ;
20725 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20726 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20727 bool result;
20728 PyObject * obj0 = 0 ;
20729 PyObject * obj1 = 0 ;
20730 PyObject * obj2 = 0 ;
20731 PyObject * obj3 = 0 ;
20732 char *kwnames[] = {
20733 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20734 };
20735
20736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20738 if (SWIG_arg_fail(1)) SWIG_fail;
20739 {
20740 arg2 = (int)(SWIG_As_int(obj1));
20741 if (SWIG_arg_fail(2)) SWIG_fail;
20742 }
20743 if (obj2) {
20744 {
20745 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20746 if (SWIG_arg_fail(3)) SWIG_fail;
20747 }
20748 }
20749 if (obj3) {
20750 {
20751 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20752 if (SWIG_arg_fail(4)) SWIG_fail;
20753 }
20754 }
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20758
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 {
20763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20764 }
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20772 PyObject *resultobj;
20773 wxDateTime *arg1 = (wxDateTime *) 0 ;
20774 int arg2 ;
20775 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20776 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20777 wxDateTime result;
20778 PyObject * obj0 = 0 ;
20779 PyObject * obj1 = 0 ;
20780 PyObject * obj2 = 0 ;
20781 PyObject * obj3 = 0 ;
20782 char *kwnames[] = {
20783 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20784 };
20785
20786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20788 if (SWIG_arg_fail(1)) SWIG_fail;
20789 {
20790 arg2 = (int)(SWIG_As_int(obj1));
20791 if (SWIG_arg_fail(2)) SWIG_fail;
20792 }
20793 if (obj2) {
20794 {
20795 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20796 if (SWIG_arg_fail(3)) SWIG_fail;
20797 }
20798 }
20799 if (obj3) {
20800 {
20801 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20802 if (SWIG_arg_fail(4)) SWIG_fail;
20803 }
20804 }
20805 {
20806 PyThreadState* __tstate = wxPyBeginAllowThreads();
20807 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20808
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 {
20813 wxDateTime * resultptr;
20814 resultptr = new wxDateTime((wxDateTime &)(result));
20815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20816 }
20817 return resultobj;
20818 fail:
20819 return NULL;
20820 }
20821
20822
20823 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20824 PyObject *resultobj;
20825 int arg1 ;
20826 int arg2 ;
20827 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20828 wxDateTime result;
20829 PyObject * obj0 = 0 ;
20830 PyObject * obj1 = 0 ;
20831 PyObject * obj2 = 0 ;
20832 char *kwnames[] = {
20833 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20834 };
20835
20836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20837 {
20838 arg1 = (int)(SWIG_As_int(obj0));
20839 if (SWIG_arg_fail(1)) SWIG_fail;
20840 }
20841 {
20842 arg2 = (int)(SWIG_As_int(obj1));
20843 if (SWIG_arg_fail(2)) SWIG_fail;
20844 }
20845 if (obj2) {
20846 {
20847 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20848 if (SWIG_arg_fail(3)) SWIG_fail;
20849 }
20850 }
20851 {
20852 PyThreadState* __tstate = wxPyBeginAllowThreads();
20853 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20854
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 {
20859 wxDateTime * resultptr;
20860 resultptr = new wxDateTime((wxDateTime &)(result));
20861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj;
20871 wxDateTime *arg1 = (wxDateTime *) 0 ;
20872 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20873 int arg3 = (int) wxDateTime::Inv_Year ;
20874 wxDateTime *result;
20875 PyObject * obj0 = 0 ;
20876 PyObject * obj1 = 0 ;
20877 PyObject * obj2 = 0 ;
20878 char *kwnames[] = {
20879 (char *) "self",(char *) "month",(char *) "year", NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20884 if (SWIG_arg_fail(1)) SWIG_fail;
20885 if (obj1) {
20886 {
20887 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20888 if (SWIG_arg_fail(2)) SWIG_fail;
20889 }
20890 }
20891 if (obj2) {
20892 {
20893 arg3 = (int)(SWIG_As_int(obj2));
20894 if (SWIG_arg_fail(3)) SWIG_fail;
20895 }
20896 }
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 {
20900 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20901 result = (wxDateTime *) &_result_ref;
20902 }
20903
20904 wxPyEndAllowThreads(__tstate);
20905 if (PyErr_Occurred()) SWIG_fail;
20906 }
20907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxDateTime *arg1 = (wxDateTime *) 0 ;
20917 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20918 int arg3 = (int) wxDateTime::Inv_Year ;
20919 wxDateTime result;
20920 PyObject * obj0 = 0 ;
20921 PyObject * obj1 = 0 ;
20922 PyObject * obj2 = 0 ;
20923 char *kwnames[] = {
20924 (char *) "self",(char *) "month",(char *) "year", NULL
20925 };
20926
20927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20929 if (SWIG_arg_fail(1)) SWIG_fail;
20930 if (obj1) {
20931 {
20932 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20933 if (SWIG_arg_fail(2)) SWIG_fail;
20934 }
20935 }
20936 if (obj2) {
20937 {
20938 arg3 = (int)(SWIG_As_int(obj2));
20939 if (SWIG_arg_fail(3)) SWIG_fail;
20940 }
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 {
20950 wxDateTime * resultptr;
20951 resultptr = new wxDateTime((wxDateTime &)(result));
20952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20953 }
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20961 PyObject *resultobj;
20962 wxDateTime *arg1 = (wxDateTime *) 0 ;
20963 int arg2 ;
20964 wxDateTime *result;
20965 PyObject * obj0 = 0 ;
20966 PyObject * obj1 = 0 ;
20967 char *kwnames[] = {
20968 (char *) "self",(char *) "yday", NULL
20969 };
20970
20971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20973 if (SWIG_arg_fail(1)) SWIG_fail;
20974 {
20975 arg2 = (int)(SWIG_As_int(obj1));
20976 if (SWIG_arg_fail(2)) SWIG_fail;
20977 }
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 {
20981 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20982 result = (wxDateTime *) &_result_ref;
20983 }
20984
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj;
20997 wxDateTime *arg1 = (wxDateTime *) 0 ;
20998 int arg2 ;
20999 wxDateTime result;
21000 PyObject * obj0 = 0 ;
21001 PyObject * obj1 = 0 ;
21002 char *kwnames[] = {
21003 (char *) "self",(char *) "yday", NULL
21004 };
21005
21006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21008 if (SWIG_arg_fail(1)) SWIG_fail;
21009 {
21010 arg2 = (int)(SWIG_As_int(obj1));
21011 if (SWIG_arg_fail(2)) SWIG_fail;
21012 }
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (arg1)->GetYearDay(arg2);
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 {
21021 wxDateTime * resultptr;
21022 resultptr = new wxDateTime((wxDateTime &)(result));
21023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21024 }
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21032 PyObject *resultobj;
21033 wxDateTime *arg1 = (wxDateTime *) 0 ;
21034 double result;
21035 PyObject * obj0 = 0 ;
21036 char *kwnames[] = {
21037 (char *) "self", NULL
21038 };
21039
21040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21042 if (SWIG_arg_fail(1)) SWIG_fail;
21043 {
21044 PyThreadState* __tstate = wxPyBeginAllowThreads();
21045 result = (double)(arg1)->GetJulianDayNumber();
21046
21047 wxPyEndAllowThreads(__tstate);
21048 if (PyErr_Occurred()) SWIG_fail;
21049 }
21050 {
21051 resultobj = SWIG_From_double((double)(result));
21052 }
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21060 PyObject *resultobj;
21061 wxDateTime *arg1 = (wxDateTime *) 0 ;
21062 double result;
21063 PyObject * obj0 = 0 ;
21064 char *kwnames[] = {
21065 (char *) "self", NULL
21066 };
21067
21068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 {
21072 PyThreadState* __tstate = wxPyBeginAllowThreads();
21073 result = (double)(arg1)->GetJDN();
21074
21075 wxPyEndAllowThreads(__tstate);
21076 if (PyErr_Occurred()) SWIG_fail;
21077 }
21078 {
21079 resultobj = SWIG_From_double((double)(result));
21080 }
21081 return resultobj;
21082 fail:
21083 return NULL;
21084 }
21085
21086
21087 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21088 PyObject *resultobj;
21089 wxDateTime *arg1 = (wxDateTime *) 0 ;
21090 double result;
21091 PyObject * obj0 = 0 ;
21092 char *kwnames[] = {
21093 (char *) "self", NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21098 if (SWIG_arg_fail(1)) SWIG_fail;
21099 {
21100 PyThreadState* __tstate = wxPyBeginAllowThreads();
21101 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21102
21103 wxPyEndAllowThreads(__tstate);
21104 if (PyErr_Occurred()) SWIG_fail;
21105 }
21106 {
21107 resultobj = SWIG_From_double((double)(result));
21108 }
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21116 PyObject *resultobj;
21117 wxDateTime *arg1 = (wxDateTime *) 0 ;
21118 double result;
21119 PyObject * obj0 = 0 ;
21120 char *kwnames[] = {
21121 (char *) "self", NULL
21122 };
21123
21124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21126 if (SWIG_arg_fail(1)) SWIG_fail;
21127 {
21128 PyThreadState* __tstate = wxPyBeginAllowThreads();
21129 result = (double)(arg1)->GetMJD();
21130
21131 wxPyEndAllowThreads(__tstate);
21132 if (PyErr_Occurred()) SWIG_fail;
21133 }
21134 {
21135 resultobj = SWIG_From_double((double)(result));
21136 }
21137 return resultobj;
21138 fail:
21139 return NULL;
21140 }
21141
21142
21143 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21144 PyObject *resultobj;
21145 wxDateTime *arg1 = (wxDateTime *) 0 ;
21146 double result;
21147 PyObject * obj0 = 0 ;
21148 char *kwnames[] = {
21149 (char *) "self", NULL
21150 };
21151
21152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21154 if (SWIG_arg_fail(1)) SWIG_fail;
21155 {
21156 PyThreadState* __tstate = wxPyBeginAllowThreads();
21157 result = (double)(arg1)->GetRataDie();
21158
21159 wxPyEndAllowThreads(__tstate);
21160 if (PyErr_Occurred()) SWIG_fail;
21161 }
21162 {
21163 resultobj = SWIG_From_double((double)(result));
21164 }
21165 return resultobj;
21166 fail:
21167 return NULL;
21168 }
21169
21170
21171 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21172 PyObject *resultobj;
21173 wxDateTime *arg1 = (wxDateTime *) 0 ;
21174 wxDateTime::TimeZone *arg2 = 0 ;
21175 bool arg3 = (bool) false ;
21176 wxDateTime result;
21177 bool temp2 = false ;
21178 PyObject * obj0 = 0 ;
21179 PyObject * obj1 = 0 ;
21180 PyObject * obj2 = 0 ;
21181 char *kwnames[] = {
21182 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21183 };
21184
21185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21187 if (SWIG_arg_fail(1)) SWIG_fail;
21188 {
21189 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21190 temp2 = true;
21191 }
21192 if (obj2) {
21193 {
21194 arg3 = (bool)(SWIG_As_bool(obj2));
21195 if (SWIG_arg_fail(3)) SWIG_fail;
21196 }
21197 }
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21201
21202 wxPyEndAllowThreads(__tstate);
21203 if (PyErr_Occurred()) SWIG_fail;
21204 }
21205 {
21206 wxDateTime * resultptr;
21207 resultptr = new wxDateTime((wxDateTime &)(result));
21208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21209 }
21210 {
21211 if (temp2) delete arg2;
21212 }
21213 return resultobj;
21214 fail:
21215 {
21216 if (temp2) delete arg2;
21217 }
21218 return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj;
21224 wxDateTime *arg1 = (wxDateTime *) 0 ;
21225 wxDateTime::TimeZone *arg2 = 0 ;
21226 bool arg3 = (bool) false ;
21227 wxDateTime *result;
21228 bool temp2 = false ;
21229 PyObject * obj0 = 0 ;
21230 PyObject * obj1 = 0 ;
21231 PyObject * obj2 = 0 ;
21232 char *kwnames[] = {
21233 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21234 };
21235
21236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21238 if (SWIG_arg_fail(1)) SWIG_fail;
21239 {
21240 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21241 temp2 = true;
21242 }
21243 if (obj2) {
21244 {
21245 arg3 = (bool)(SWIG_As_bool(obj2));
21246 if (SWIG_arg_fail(3)) SWIG_fail;
21247 }
21248 }
21249 {
21250 PyThreadState* __tstate = wxPyBeginAllowThreads();
21251 {
21252 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21253 result = (wxDateTime *) &_result_ref;
21254 }
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21260 {
21261 if (temp2) delete arg2;
21262 }
21263 return resultobj;
21264 fail:
21265 {
21266 if (temp2) delete arg2;
21267 }
21268 return NULL;
21269 }
21270
21271
21272 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21273 PyObject *resultobj;
21274 wxDateTime *arg1 = (wxDateTime *) 0 ;
21275 bool arg2 = (bool) false ;
21276 wxDateTime result;
21277 PyObject * obj0 = 0 ;
21278 PyObject * obj1 = 0 ;
21279 char *kwnames[] = {
21280 (char *) "self",(char *) "noDST", NULL
21281 };
21282
21283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21285 if (SWIG_arg_fail(1)) SWIG_fail;
21286 if (obj1) {
21287 {
21288 arg2 = (bool)(SWIG_As_bool(obj1));
21289 if (SWIG_arg_fail(2)) SWIG_fail;
21290 }
21291 }
21292 {
21293 PyThreadState* __tstate = wxPyBeginAllowThreads();
21294 result = (arg1)->ToGMT(arg2);
21295
21296 wxPyEndAllowThreads(__tstate);
21297 if (PyErr_Occurred()) SWIG_fail;
21298 }
21299 {
21300 wxDateTime * resultptr;
21301 resultptr = new wxDateTime((wxDateTime &)(result));
21302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21303 }
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj;
21312 wxDateTime *arg1 = (wxDateTime *) 0 ;
21313 bool arg2 = (bool) false ;
21314 wxDateTime *result;
21315 PyObject * obj0 = 0 ;
21316 PyObject * obj1 = 0 ;
21317 char *kwnames[] = {
21318 (char *) "self",(char *) "noDST", NULL
21319 };
21320
21321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21323 if (SWIG_arg_fail(1)) SWIG_fail;
21324 if (obj1) {
21325 {
21326 arg2 = (bool)(SWIG_As_bool(obj1));
21327 if (SWIG_arg_fail(2)) SWIG_fail;
21328 }
21329 }
21330 {
21331 PyThreadState* __tstate = wxPyBeginAllowThreads();
21332 {
21333 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21334 result = (wxDateTime *) &_result_ref;
21335 }
21336
21337 wxPyEndAllowThreads(__tstate);
21338 if (PyErr_Occurred()) SWIG_fail;
21339 }
21340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21341 return resultobj;
21342 fail:
21343 return NULL;
21344 }
21345
21346
21347 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21348 PyObject *resultobj;
21349 wxDateTime *arg1 = (wxDateTime *) 0 ;
21350 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21351 int result;
21352 PyObject * obj0 = 0 ;
21353 PyObject * obj1 = 0 ;
21354 char *kwnames[] = {
21355 (char *) "self",(char *) "country", NULL
21356 };
21357
21358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21360 if (SWIG_arg_fail(1)) SWIG_fail;
21361 if (obj1) {
21362 {
21363 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21364 if (SWIG_arg_fail(2)) SWIG_fail;
21365 }
21366 }
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21370
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 {
21375 resultobj = SWIG_From_int((int)(result));
21376 }
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj;
21385 wxDateTime *arg1 = (wxDateTime *) 0 ;
21386 bool result;
21387 PyObject * obj0 = 0 ;
21388 char *kwnames[] = {
21389 (char *) "self", NULL
21390 };
21391
21392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21394 if (SWIG_arg_fail(1)) SWIG_fail;
21395 {
21396 PyThreadState* __tstate = wxPyBeginAllowThreads();
21397 result = (bool)((wxDateTime const *)arg1)->IsValid();
21398
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 {
21403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21404 }
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj;
21413 wxDateTime *arg1 = (wxDateTime *) 0 ;
21414 time_t result;
21415 PyObject * obj0 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 PyThreadState* __tstate = wxPyBeginAllowThreads();
21425 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21426
21427 wxPyEndAllowThreads(__tstate);
21428 if (PyErr_Occurred()) SWIG_fail;
21429 }
21430 {
21431 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21432 }
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21440 PyObject *resultobj;
21441 wxDateTime *arg1 = (wxDateTime *) 0 ;
21442 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21443 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21444 int result;
21445 bool temp2 = false ;
21446 PyObject * obj0 = 0 ;
21447 PyObject * obj1 = 0 ;
21448 char *kwnames[] = {
21449 (char *) "self",(char *) "tz", NULL
21450 };
21451
21452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21454 if (SWIG_arg_fail(1)) SWIG_fail;
21455 if (obj1) {
21456 {
21457 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21458 temp2 = true;
21459 }
21460 }
21461 {
21462 PyThreadState* __tstate = wxPyBeginAllowThreads();
21463 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21464
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = SWIG_From_int((int)(result));
21470 }
21471 {
21472 if (temp2) delete arg2;
21473 }
21474 return resultobj;
21475 fail:
21476 {
21477 if (temp2) delete arg2;
21478 }
21479 return NULL;
21480 }
21481
21482
21483 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21484 PyObject *resultobj;
21485 wxDateTime *arg1 = (wxDateTime *) 0 ;
21486 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21487 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21488 wxDateTime::Month result;
21489 bool temp2 = false ;
21490 PyObject * obj0 = 0 ;
21491 PyObject * obj1 = 0 ;
21492 char *kwnames[] = {
21493 (char *) "self",(char *) "tz", NULL
21494 };
21495
21496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21498 if (SWIG_arg_fail(1)) SWIG_fail;
21499 if (obj1) {
21500 {
21501 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21502 temp2 = true;
21503 }
21504 }
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21508
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 resultobj = SWIG_From_int((result));
21513 {
21514 if (temp2) delete arg2;
21515 }
21516 return resultobj;
21517 fail:
21518 {
21519 if (temp2) delete arg2;
21520 }
21521 return NULL;
21522 }
21523
21524
21525 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21526 PyObject *resultobj;
21527 wxDateTime *arg1 = (wxDateTime *) 0 ;
21528 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21529 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21530 int result;
21531 bool temp2 = false ;
21532 PyObject * obj0 = 0 ;
21533 PyObject * obj1 = 0 ;
21534 char *kwnames[] = {
21535 (char *) "self",(char *) "tz", NULL
21536 };
21537
21538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21540 if (SWIG_arg_fail(1)) SWIG_fail;
21541 if (obj1) {
21542 {
21543 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21544 temp2 = true;
21545 }
21546 }
21547 {
21548 PyThreadState* __tstate = wxPyBeginAllowThreads();
21549 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21550
21551 wxPyEndAllowThreads(__tstate);
21552 if (PyErr_Occurred()) SWIG_fail;
21553 }
21554 {
21555 resultobj = SWIG_From_int((int)(result));
21556 }
21557 {
21558 if (temp2) delete arg2;
21559 }
21560 return resultobj;
21561 fail:
21562 {
21563 if (temp2) delete arg2;
21564 }
21565 return NULL;
21566 }
21567
21568
21569 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21570 PyObject *resultobj;
21571 wxDateTime *arg1 = (wxDateTime *) 0 ;
21572 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21573 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21574 wxDateTime::WeekDay result;
21575 bool temp2 = false ;
21576 PyObject * obj0 = 0 ;
21577 PyObject * obj1 = 0 ;
21578 char *kwnames[] = {
21579 (char *) "self",(char *) "tz", NULL
21580 };
21581
21582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21584 if (SWIG_arg_fail(1)) SWIG_fail;
21585 if (obj1) {
21586 {
21587 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21588 temp2 = true;
21589 }
21590 }
21591 {
21592 PyThreadState* __tstate = wxPyBeginAllowThreads();
21593 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21594
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 resultobj = SWIG_From_int((result));
21599 {
21600 if (temp2) delete arg2;
21601 }
21602 return resultobj;
21603 fail:
21604 {
21605 if (temp2) delete arg2;
21606 }
21607 return NULL;
21608 }
21609
21610
21611 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21612 PyObject *resultobj;
21613 wxDateTime *arg1 = (wxDateTime *) 0 ;
21614 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21615 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21616 int result;
21617 bool temp2 = false ;
21618 PyObject * obj0 = 0 ;
21619 PyObject * obj1 = 0 ;
21620 char *kwnames[] = {
21621 (char *) "self",(char *) "tz", NULL
21622 };
21623
21624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21626 if (SWIG_arg_fail(1)) SWIG_fail;
21627 if (obj1) {
21628 {
21629 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21630 temp2 = true;
21631 }
21632 }
21633 {
21634 PyThreadState* __tstate = wxPyBeginAllowThreads();
21635 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21636
21637 wxPyEndAllowThreads(__tstate);
21638 if (PyErr_Occurred()) SWIG_fail;
21639 }
21640 {
21641 resultobj = SWIG_From_int((int)(result));
21642 }
21643 {
21644 if (temp2) delete arg2;
21645 }
21646 return resultobj;
21647 fail:
21648 {
21649 if (temp2) delete arg2;
21650 }
21651 return NULL;
21652 }
21653
21654
21655 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21656 PyObject *resultobj;
21657 wxDateTime *arg1 = (wxDateTime *) 0 ;
21658 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21659 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21660 int result;
21661 bool temp2 = false ;
21662 PyObject * obj0 = 0 ;
21663 PyObject * obj1 = 0 ;
21664 char *kwnames[] = {
21665 (char *) "self",(char *) "tz", NULL
21666 };
21667
21668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21670 if (SWIG_arg_fail(1)) SWIG_fail;
21671 if (obj1) {
21672 {
21673 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21674 temp2 = true;
21675 }
21676 }
21677 {
21678 PyThreadState* __tstate = wxPyBeginAllowThreads();
21679 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21680
21681 wxPyEndAllowThreads(__tstate);
21682 if (PyErr_Occurred()) SWIG_fail;
21683 }
21684 {
21685 resultobj = SWIG_From_int((int)(result));
21686 }
21687 {
21688 if (temp2) delete arg2;
21689 }
21690 return resultobj;
21691 fail:
21692 {
21693 if (temp2) delete arg2;
21694 }
21695 return NULL;
21696 }
21697
21698
21699 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21700 PyObject *resultobj;
21701 wxDateTime *arg1 = (wxDateTime *) 0 ;
21702 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21703 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21704 int result;
21705 bool temp2 = false ;
21706 PyObject * obj0 = 0 ;
21707 PyObject * obj1 = 0 ;
21708 char *kwnames[] = {
21709 (char *) "self",(char *) "tz", NULL
21710 };
21711
21712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21714 if (SWIG_arg_fail(1)) SWIG_fail;
21715 if (obj1) {
21716 {
21717 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21718 temp2 = true;
21719 }
21720 }
21721 {
21722 PyThreadState* __tstate = wxPyBeginAllowThreads();
21723 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21724
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 {
21729 resultobj = SWIG_From_int((int)(result));
21730 }
21731 {
21732 if (temp2) delete arg2;
21733 }
21734 return resultobj;
21735 fail:
21736 {
21737 if (temp2) delete arg2;
21738 }
21739 return NULL;
21740 }
21741
21742
21743 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21744 PyObject *resultobj;
21745 wxDateTime *arg1 = (wxDateTime *) 0 ;
21746 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21747 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21748 int result;
21749 bool temp2 = false ;
21750 PyObject * obj0 = 0 ;
21751 PyObject * obj1 = 0 ;
21752 char *kwnames[] = {
21753 (char *) "self",(char *) "tz", NULL
21754 };
21755
21756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21758 if (SWIG_arg_fail(1)) SWIG_fail;
21759 if (obj1) {
21760 {
21761 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21762 temp2 = true;
21763 }
21764 }
21765 {
21766 PyThreadState* __tstate = wxPyBeginAllowThreads();
21767 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21768
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 {
21773 resultobj = SWIG_From_int((int)(result));
21774 }
21775 {
21776 if (temp2) delete arg2;
21777 }
21778 return resultobj;
21779 fail:
21780 {
21781 if (temp2) delete arg2;
21782 }
21783 return NULL;
21784 }
21785
21786
21787 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21788 PyObject *resultobj;
21789 wxDateTime *arg1 = (wxDateTime *) 0 ;
21790 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21791 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21792 int result;
21793 bool temp2 = false ;
21794 PyObject * obj0 = 0 ;
21795 PyObject * obj1 = 0 ;
21796 char *kwnames[] = {
21797 (char *) "self",(char *) "tz", NULL
21798 };
21799
21800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21802 if (SWIG_arg_fail(1)) SWIG_fail;
21803 if (obj1) {
21804 {
21805 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21806 temp2 = true;
21807 }
21808 }
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21812
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 {
21817 resultobj = SWIG_From_int((int)(result));
21818 }
21819 {
21820 if (temp2) delete arg2;
21821 }
21822 return resultobj;
21823 fail:
21824 {
21825 if (temp2) delete arg2;
21826 }
21827 return NULL;
21828 }
21829
21830
21831 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21832 PyObject *resultobj;
21833 wxDateTime *arg1 = (wxDateTime *) 0 ;
21834 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21835 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21836 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21837 int result;
21838 bool temp3 = false ;
21839 PyObject * obj0 = 0 ;
21840 PyObject * obj1 = 0 ;
21841 PyObject * obj2 = 0 ;
21842 char *kwnames[] = {
21843 (char *) "self",(char *) "flags",(char *) "tz", NULL
21844 };
21845
21846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(1)) SWIG_fail;
21849 if (obj1) {
21850 {
21851 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21852 if (SWIG_arg_fail(2)) SWIG_fail;
21853 }
21854 }
21855 if (obj2) {
21856 {
21857 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21858 temp3 = true;
21859 }
21860 }
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21864
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 {
21869 resultobj = SWIG_From_int((int)(result));
21870 }
21871 {
21872 if (temp3) delete arg3;
21873 }
21874 return resultobj;
21875 fail:
21876 {
21877 if (temp3) delete arg3;
21878 }
21879 return NULL;
21880 }
21881
21882
21883 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21884 PyObject *resultobj;
21885 wxDateTime *arg1 = (wxDateTime *) 0 ;
21886 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21887 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21888 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21889 int result;
21890 bool temp3 = false ;
21891 PyObject * obj0 = 0 ;
21892 PyObject * obj1 = 0 ;
21893 PyObject * obj2 = 0 ;
21894 char *kwnames[] = {
21895 (char *) "self",(char *) "flags",(char *) "tz", NULL
21896 };
21897
21898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21900 if (SWIG_arg_fail(1)) SWIG_fail;
21901 if (obj1) {
21902 {
21903 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21904 if (SWIG_arg_fail(2)) SWIG_fail;
21905 }
21906 }
21907 if (obj2) {
21908 {
21909 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21910 temp3 = true;
21911 }
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21916
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = SWIG_From_int((int)(result));
21922 }
21923 {
21924 if (temp3) delete arg3;
21925 }
21926 return resultobj;
21927 fail:
21928 {
21929 if (temp3) delete arg3;
21930 }
21931 return NULL;
21932 }
21933
21934
21935 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21936 PyObject *resultobj;
21937 wxDateTime *arg1 = (wxDateTime *) 0 ;
21938 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21939 bool result;
21940 PyObject * obj0 = 0 ;
21941 PyObject * obj1 = 0 ;
21942 char *kwnames[] = {
21943 (char *) "self",(char *) "country", NULL
21944 };
21945
21946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21948 if (SWIG_arg_fail(1)) SWIG_fail;
21949 if (obj1) {
21950 {
21951 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21952 if (SWIG_arg_fail(2)) SWIG_fail;
21953 }
21954 }
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21958
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 {
21963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21964 }
21965 return resultobj;
21966 fail:
21967 return NULL;
21968 }
21969
21970
21971 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21972 PyObject *resultobj;
21973 wxDateTime *arg1 = (wxDateTime *) 0 ;
21974 wxDateTime *arg2 = 0 ;
21975 bool result;
21976 PyObject * obj0 = 0 ;
21977 PyObject * obj1 = 0 ;
21978 char *kwnames[] = {
21979 (char *) "self",(char *) "datetime", NULL
21980 };
21981
21982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21984 if (SWIG_arg_fail(1)) SWIG_fail;
21985 {
21986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21987 if (SWIG_arg_fail(2)) SWIG_fail;
21988 if (arg2 == NULL) {
21989 SWIG_null_ref("wxDateTime");
21990 }
21991 if (SWIG_arg_fail(2)) SWIG_fail;
21992 }
21993 {
21994 PyThreadState* __tstate = wxPyBeginAllowThreads();
21995 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 {
22001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22002 }
22003 return resultobj;
22004 fail:
22005 return NULL;
22006 }
22007
22008
22009 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22010 PyObject *resultobj;
22011 wxDateTime *arg1 = (wxDateTime *) 0 ;
22012 wxDateTime *arg2 = 0 ;
22013 bool result;
22014 PyObject * obj0 = 0 ;
22015 PyObject * obj1 = 0 ;
22016 char *kwnames[] = {
22017 (char *) "self",(char *) "datetime", NULL
22018 };
22019
22020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22022 if (SWIG_arg_fail(1)) SWIG_fail;
22023 {
22024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(2)) SWIG_fail;
22026 if (arg2 == NULL) {
22027 SWIG_null_ref("wxDateTime");
22028 }
22029 if (SWIG_arg_fail(2)) SWIG_fail;
22030 }
22031 {
22032 PyThreadState* __tstate = wxPyBeginAllowThreads();
22033 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22034
22035 wxPyEndAllowThreads(__tstate);
22036 if (PyErr_Occurred()) SWIG_fail;
22037 }
22038 {
22039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22040 }
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22048 PyObject *resultobj;
22049 wxDateTime *arg1 = (wxDateTime *) 0 ;
22050 wxDateTime *arg2 = 0 ;
22051 bool result;
22052 PyObject * obj0 = 0 ;
22053 PyObject * obj1 = 0 ;
22054 char *kwnames[] = {
22055 (char *) "self",(char *) "datetime", NULL
22056 };
22057
22058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22060 if (SWIG_arg_fail(1)) SWIG_fail;
22061 {
22062 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22063 if (SWIG_arg_fail(2)) SWIG_fail;
22064 if (arg2 == NULL) {
22065 SWIG_null_ref("wxDateTime");
22066 }
22067 if (SWIG_arg_fail(2)) SWIG_fail;
22068 }
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22072
22073 wxPyEndAllowThreads(__tstate);
22074 if (PyErr_Occurred()) SWIG_fail;
22075 }
22076 {
22077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22078 }
22079 return resultobj;
22080 fail:
22081 return NULL;
22082 }
22083
22084
22085 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22086 PyObject *resultobj;
22087 wxDateTime *arg1 = (wxDateTime *) 0 ;
22088 wxDateTime *arg2 = 0 ;
22089 wxDateTime *arg3 = 0 ;
22090 bool result;
22091 PyObject * obj0 = 0 ;
22092 PyObject * obj1 = 0 ;
22093 PyObject * obj2 = 0 ;
22094 char *kwnames[] = {
22095 (char *) "self",(char *) "t1",(char *) "t2", NULL
22096 };
22097
22098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22100 if (SWIG_arg_fail(1)) SWIG_fail;
22101 {
22102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(2)) SWIG_fail;
22104 if (arg2 == NULL) {
22105 SWIG_null_ref("wxDateTime");
22106 }
22107 if (SWIG_arg_fail(2)) SWIG_fail;
22108 }
22109 {
22110 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22111 if (SWIG_arg_fail(3)) SWIG_fail;
22112 if (arg3 == NULL) {
22113 SWIG_null_ref("wxDateTime");
22114 }
22115 if (SWIG_arg_fail(3)) SWIG_fail;
22116 }
22117 {
22118 PyThreadState* __tstate = wxPyBeginAllowThreads();
22119 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22120
22121 wxPyEndAllowThreads(__tstate);
22122 if (PyErr_Occurred()) SWIG_fail;
22123 }
22124 {
22125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22126 }
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj;
22135 wxDateTime *arg1 = (wxDateTime *) 0 ;
22136 wxDateTime *arg2 = 0 ;
22137 wxDateTime *arg3 = 0 ;
22138 bool result;
22139 PyObject * obj0 = 0 ;
22140 PyObject * obj1 = 0 ;
22141 PyObject * obj2 = 0 ;
22142 char *kwnames[] = {
22143 (char *) "self",(char *) "t1",(char *) "t2", NULL
22144 };
22145
22146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22148 if (SWIG_arg_fail(1)) SWIG_fail;
22149 {
22150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22151 if (SWIG_arg_fail(2)) SWIG_fail;
22152 if (arg2 == NULL) {
22153 SWIG_null_ref("wxDateTime");
22154 }
22155 if (SWIG_arg_fail(2)) SWIG_fail;
22156 }
22157 {
22158 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22159 if (SWIG_arg_fail(3)) SWIG_fail;
22160 if (arg3 == NULL) {
22161 SWIG_null_ref("wxDateTime");
22162 }
22163 if (SWIG_arg_fail(3)) SWIG_fail;
22164 }
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22168
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 {
22173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22174 }
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22182 PyObject *resultobj;
22183 wxDateTime *arg1 = (wxDateTime *) 0 ;
22184 wxDateTime *arg2 = 0 ;
22185 bool result;
22186 PyObject * obj0 = 0 ;
22187 PyObject * obj1 = 0 ;
22188 char *kwnames[] = {
22189 (char *) "self",(char *) "dt", NULL
22190 };
22191
22192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22194 if (SWIG_arg_fail(1)) SWIG_fail;
22195 {
22196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22197 if (SWIG_arg_fail(2)) SWIG_fail;
22198 if (arg2 == NULL) {
22199 SWIG_null_ref("wxDateTime");
22200 }
22201 if (SWIG_arg_fail(2)) SWIG_fail;
22202 }
22203 {
22204 PyThreadState* __tstate = wxPyBeginAllowThreads();
22205 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22206
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 {
22211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22212 }
22213 return resultobj;
22214 fail:
22215 return NULL;
22216 }
22217
22218
22219 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22220 PyObject *resultobj;
22221 wxDateTime *arg1 = (wxDateTime *) 0 ;
22222 wxDateTime *arg2 = 0 ;
22223 bool result;
22224 PyObject * obj0 = 0 ;
22225 PyObject * obj1 = 0 ;
22226 char *kwnames[] = {
22227 (char *) "self",(char *) "dt", NULL
22228 };
22229
22230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22232 if (SWIG_arg_fail(1)) SWIG_fail;
22233 {
22234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22235 if (SWIG_arg_fail(2)) SWIG_fail;
22236 if (arg2 == NULL) {
22237 SWIG_null_ref("wxDateTime");
22238 }
22239 if (SWIG_arg_fail(2)) SWIG_fail;
22240 }
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22244
22245 wxPyEndAllowThreads(__tstate);
22246 if (PyErr_Occurred()) SWIG_fail;
22247 }
22248 {
22249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22250 }
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22258 PyObject *resultobj;
22259 wxDateTime *arg1 = (wxDateTime *) 0 ;
22260 wxDateTime *arg2 = 0 ;
22261 wxTimeSpan *arg3 = 0 ;
22262 bool result;
22263 PyObject * obj0 = 0 ;
22264 PyObject * obj1 = 0 ;
22265 PyObject * obj2 = 0 ;
22266 char *kwnames[] = {
22267 (char *) "self",(char *) "dt",(char *) "ts", NULL
22268 };
22269
22270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22272 if (SWIG_arg_fail(1)) SWIG_fail;
22273 {
22274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22275 if (SWIG_arg_fail(2)) SWIG_fail;
22276 if (arg2 == NULL) {
22277 SWIG_null_ref("wxDateTime");
22278 }
22279 if (SWIG_arg_fail(2)) SWIG_fail;
22280 }
22281 {
22282 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22283 if (SWIG_arg_fail(3)) SWIG_fail;
22284 if (arg3 == NULL) {
22285 SWIG_null_ref("wxTimeSpan");
22286 }
22287 if (SWIG_arg_fail(3)) SWIG_fail;
22288 }
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22292
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 {
22297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22298 }
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22306 PyObject *resultobj;
22307 wxDateTime *arg1 = (wxDateTime *) 0 ;
22308 wxTimeSpan *arg2 = 0 ;
22309 wxDateTime *result;
22310 PyObject * obj0 = 0 ;
22311 PyObject * obj1 = 0 ;
22312 char *kwnames[] = {
22313 (char *) "self",(char *) "diff", NULL
22314 };
22315
22316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22318 if (SWIG_arg_fail(1)) SWIG_fail;
22319 {
22320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22321 if (SWIG_arg_fail(2)) SWIG_fail;
22322 if (arg2 == NULL) {
22323 SWIG_null_ref("wxTimeSpan");
22324 }
22325 if (SWIG_arg_fail(2)) SWIG_fail;
22326 }
22327 {
22328 PyThreadState* __tstate = wxPyBeginAllowThreads();
22329 {
22330 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22331 result = (wxDateTime *) &_result_ref;
22332 }
22333
22334 wxPyEndAllowThreads(__tstate);
22335 if (PyErr_Occurred()) SWIG_fail;
22336 }
22337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj;
22346 wxDateTime *arg1 = (wxDateTime *) 0 ;
22347 wxDateSpan *arg2 = 0 ;
22348 wxDateTime *result;
22349 PyObject * obj0 = 0 ;
22350 PyObject * obj1 = 0 ;
22351 char *kwnames[] = {
22352 (char *) "self",(char *) "diff", NULL
22353 };
22354
22355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22357 if (SWIG_arg_fail(1)) SWIG_fail;
22358 {
22359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22360 if (SWIG_arg_fail(2)) SWIG_fail;
22361 if (arg2 == NULL) {
22362 SWIG_null_ref("wxDateSpan");
22363 }
22364 if (SWIG_arg_fail(2)) SWIG_fail;
22365 }
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 {
22369 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22370 result = (wxDateTime *) &_result_ref;
22371 }
22372
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22384 PyObject *resultobj;
22385 wxDateTime *arg1 = (wxDateTime *) 0 ;
22386 wxTimeSpan *arg2 = 0 ;
22387 wxDateTime *result;
22388 PyObject * obj0 = 0 ;
22389 PyObject * obj1 = 0 ;
22390 char *kwnames[] = {
22391 (char *) "self",(char *) "diff", NULL
22392 };
22393
22394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22396 if (SWIG_arg_fail(1)) SWIG_fail;
22397 {
22398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22399 if (SWIG_arg_fail(2)) SWIG_fail;
22400 if (arg2 == NULL) {
22401 SWIG_null_ref("wxTimeSpan");
22402 }
22403 if (SWIG_arg_fail(2)) SWIG_fail;
22404 }
22405 {
22406 PyThreadState* __tstate = wxPyBeginAllowThreads();
22407 {
22408 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22409 result = (wxDateTime *) &_result_ref;
22410 }
22411
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22423 PyObject *resultobj;
22424 wxDateTime *arg1 = (wxDateTime *) 0 ;
22425 wxDateSpan *arg2 = 0 ;
22426 wxDateTime *result;
22427 PyObject * obj0 = 0 ;
22428 PyObject * obj1 = 0 ;
22429 char *kwnames[] = {
22430 (char *) "self",(char *) "diff", NULL
22431 };
22432
22433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22435 if (SWIG_arg_fail(1)) SWIG_fail;
22436 {
22437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(2)) SWIG_fail;
22439 if (arg2 == NULL) {
22440 SWIG_null_ref("wxDateSpan");
22441 }
22442 if (SWIG_arg_fail(2)) SWIG_fail;
22443 }
22444 {
22445 PyThreadState* __tstate = wxPyBeginAllowThreads();
22446 {
22447 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22448 result = (wxDateTime *) &_result_ref;
22449 }
22450
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj;
22463 wxDateTime *arg1 = (wxDateTime *) 0 ;
22464 wxDateTime *arg2 = 0 ;
22465 wxTimeSpan result;
22466 PyObject * obj0 = 0 ;
22467 PyObject * obj1 = 0 ;
22468 char *kwnames[] = {
22469 (char *) "self",(char *) "dt", NULL
22470 };
22471
22472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 {
22476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22477 if (SWIG_arg_fail(2)) SWIG_fail;
22478 if (arg2 == NULL) {
22479 SWIG_null_ref("wxDateTime");
22480 }
22481 if (SWIG_arg_fail(2)) SWIG_fail;
22482 }
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22486
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 {
22491 wxTimeSpan * resultptr;
22492 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22493 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22494 }
22495 return resultobj;
22496 fail:
22497 return NULL;
22498 }
22499
22500
22501 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22502 PyObject *resultobj;
22503 wxDateTime *arg1 = (wxDateTime *) 0 ;
22504 wxTimeSpan *arg2 = 0 ;
22505 wxDateTime *result;
22506 PyObject * obj0 = 0 ;
22507 PyObject * obj1 = 0 ;
22508
22509 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22511 if (SWIG_arg_fail(1)) SWIG_fail;
22512 {
22513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22514 if (SWIG_arg_fail(2)) SWIG_fail;
22515 if (arg2 == NULL) {
22516 SWIG_null_ref("wxTimeSpan");
22517 }
22518 if (SWIG_arg_fail(2)) SWIG_fail;
22519 }
22520 {
22521 PyThreadState* __tstate = wxPyBeginAllowThreads();
22522 {
22523 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22524 result = (wxDateTime *) &_result_ref;
22525 }
22526
22527 wxPyEndAllowThreads(__tstate);
22528 if (PyErr_Occurred()) SWIG_fail;
22529 }
22530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22531 return resultobj;
22532 fail:
22533 return NULL;
22534 }
22535
22536
22537 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22538 PyObject *resultobj;
22539 wxDateTime *arg1 = (wxDateTime *) 0 ;
22540 wxDateSpan *arg2 = 0 ;
22541 wxDateTime *result;
22542 PyObject * obj0 = 0 ;
22543 PyObject * obj1 = 0 ;
22544
22545 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22547 if (SWIG_arg_fail(1)) SWIG_fail;
22548 {
22549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22550 if (SWIG_arg_fail(2)) SWIG_fail;
22551 if (arg2 == NULL) {
22552 SWIG_null_ref("wxDateSpan");
22553 }
22554 if (SWIG_arg_fail(2)) SWIG_fail;
22555 }
22556 {
22557 PyThreadState* __tstate = wxPyBeginAllowThreads();
22558 {
22559 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22560 result = (wxDateTime *) &_result_ref;
22561 }
22562
22563 wxPyEndAllowThreads(__tstate);
22564 if (PyErr_Occurred()) SWIG_fail;
22565 }
22566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22567 return resultobj;
22568 fail:
22569 return NULL;
22570 }
22571
22572
22573 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22574 int argc;
22575 PyObject *argv[3];
22576 int ii;
22577
22578 argc = PyObject_Length(args);
22579 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22580 argv[ii] = PyTuple_GetItem(args,ii);
22581 }
22582 if (argc == 2) {
22583 int _v;
22584 {
22585 void *ptr;
22586 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22587 _v = 0;
22588 PyErr_Clear();
22589 } else {
22590 _v = 1;
22591 }
22592 }
22593 if (_v) {
22594 {
22595 void *ptr = 0;
22596 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22597 _v = 0;
22598 PyErr_Clear();
22599 } else {
22600 _v = (ptr != 0);
22601 }
22602 }
22603 if (_v) {
22604 return _wrap_DateTime___iadd____SWIG_0(self,args);
22605 }
22606 }
22607 }
22608 if (argc == 2) {
22609 int _v;
22610 {
22611 void *ptr;
22612 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22613 _v = 0;
22614 PyErr_Clear();
22615 } else {
22616 _v = 1;
22617 }
22618 }
22619 if (_v) {
22620 {
22621 void *ptr = 0;
22622 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22623 _v = 0;
22624 PyErr_Clear();
22625 } else {
22626 _v = (ptr != 0);
22627 }
22628 }
22629 if (_v) {
22630 return _wrap_DateTime___iadd____SWIG_1(self,args);
22631 }
22632 }
22633 }
22634
22635 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22636 return NULL;
22637 }
22638
22639
22640 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22641 PyObject *resultobj;
22642 wxDateTime *arg1 = (wxDateTime *) 0 ;
22643 wxTimeSpan *arg2 = 0 ;
22644 wxDateTime *result;
22645 PyObject * obj0 = 0 ;
22646 PyObject * obj1 = 0 ;
22647
22648 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22650 if (SWIG_arg_fail(1)) SWIG_fail;
22651 {
22652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22653 if (SWIG_arg_fail(2)) SWIG_fail;
22654 if (arg2 == NULL) {
22655 SWIG_null_ref("wxTimeSpan");
22656 }
22657 if (SWIG_arg_fail(2)) SWIG_fail;
22658 }
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 {
22662 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22663 result = (wxDateTime *) &_result_ref;
22664 }
22665
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22677 PyObject *resultobj;
22678 wxDateTime *arg1 = (wxDateTime *) 0 ;
22679 wxDateSpan *arg2 = 0 ;
22680 wxDateTime *result;
22681 PyObject * obj0 = 0 ;
22682 PyObject * obj1 = 0 ;
22683
22684 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22686 if (SWIG_arg_fail(1)) SWIG_fail;
22687 {
22688 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22689 if (SWIG_arg_fail(2)) SWIG_fail;
22690 if (arg2 == NULL) {
22691 SWIG_null_ref("wxDateSpan");
22692 }
22693 if (SWIG_arg_fail(2)) SWIG_fail;
22694 }
22695 {
22696 PyThreadState* __tstate = wxPyBeginAllowThreads();
22697 {
22698 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22699 result = (wxDateTime *) &_result_ref;
22700 }
22701
22702 wxPyEndAllowThreads(__tstate);
22703 if (PyErr_Occurred()) SWIG_fail;
22704 }
22705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22706 return resultobj;
22707 fail:
22708 return NULL;
22709 }
22710
22711
22712 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22713 int argc;
22714 PyObject *argv[3];
22715 int ii;
22716
22717 argc = PyObject_Length(args);
22718 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22719 argv[ii] = PyTuple_GetItem(args,ii);
22720 }
22721 if (argc == 2) {
22722 int _v;
22723 {
22724 void *ptr;
22725 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22726 _v = 0;
22727 PyErr_Clear();
22728 } else {
22729 _v = 1;
22730 }
22731 }
22732 if (_v) {
22733 {
22734 void *ptr = 0;
22735 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22736 _v = 0;
22737 PyErr_Clear();
22738 } else {
22739 _v = (ptr != 0);
22740 }
22741 }
22742 if (_v) {
22743 return _wrap_DateTime___isub____SWIG_0(self,args);
22744 }
22745 }
22746 }
22747 if (argc == 2) {
22748 int _v;
22749 {
22750 void *ptr;
22751 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22752 _v = 0;
22753 PyErr_Clear();
22754 } else {
22755 _v = 1;
22756 }
22757 }
22758 if (_v) {
22759 {
22760 void *ptr = 0;
22761 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22762 _v = 0;
22763 PyErr_Clear();
22764 } else {
22765 _v = (ptr != 0);
22766 }
22767 }
22768 if (_v) {
22769 return _wrap_DateTime___isub____SWIG_1(self,args);
22770 }
22771 }
22772 }
22773
22774 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22775 return NULL;
22776 }
22777
22778
22779 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22780 PyObject *resultobj;
22781 wxDateTime *arg1 = (wxDateTime *) 0 ;
22782 wxTimeSpan *arg2 = 0 ;
22783 wxDateTime result;
22784 PyObject * obj0 = 0 ;
22785 PyObject * obj1 = 0 ;
22786
22787 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22789 if (SWIG_arg_fail(1)) SWIG_fail;
22790 {
22791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22792 if (SWIG_arg_fail(2)) SWIG_fail;
22793 if (arg2 == NULL) {
22794 SWIG_null_ref("wxTimeSpan");
22795 }
22796 if (SWIG_arg_fail(2)) SWIG_fail;
22797 }
22798 {
22799 PyThreadState* __tstate = wxPyBeginAllowThreads();
22800 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22801
22802 wxPyEndAllowThreads(__tstate);
22803 if (PyErr_Occurred()) SWIG_fail;
22804 }
22805 {
22806 wxDateTime * resultptr;
22807 resultptr = new wxDateTime((wxDateTime &)(result));
22808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22809 }
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22817 PyObject *resultobj;
22818 wxDateTime *arg1 = (wxDateTime *) 0 ;
22819 wxDateSpan *arg2 = 0 ;
22820 wxDateTime result;
22821 PyObject * obj0 = 0 ;
22822 PyObject * obj1 = 0 ;
22823
22824 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22826 if (SWIG_arg_fail(1)) SWIG_fail;
22827 {
22828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22829 if (SWIG_arg_fail(2)) SWIG_fail;
22830 if (arg2 == NULL) {
22831 SWIG_null_ref("wxDateSpan");
22832 }
22833 if (SWIG_arg_fail(2)) SWIG_fail;
22834 }
22835 {
22836 PyThreadState* __tstate = wxPyBeginAllowThreads();
22837 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22838
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 {
22843 wxDateTime * resultptr;
22844 resultptr = new wxDateTime((wxDateTime &)(result));
22845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22846 }
22847 return resultobj;
22848 fail:
22849 return NULL;
22850 }
22851
22852
22853 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22854 int argc;
22855 PyObject *argv[3];
22856 int ii;
22857
22858 argc = PyObject_Length(args);
22859 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22860 argv[ii] = PyTuple_GetItem(args,ii);
22861 }
22862 if (argc == 2) {
22863 int _v;
22864 {
22865 void *ptr;
22866 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22867 _v = 0;
22868 PyErr_Clear();
22869 } else {
22870 _v = 1;
22871 }
22872 }
22873 if (_v) {
22874 {
22875 void *ptr = 0;
22876 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22877 _v = 0;
22878 PyErr_Clear();
22879 } else {
22880 _v = (ptr != 0);
22881 }
22882 }
22883 if (_v) {
22884 return _wrap_DateTime___add____SWIG_0(self,args);
22885 }
22886 }
22887 }
22888 if (argc == 2) {
22889 int _v;
22890 {
22891 void *ptr;
22892 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22893 _v = 0;
22894 PyErr_Clear();
22895 } else {
22896 _v = 1;
22897 }
22898 }
22899 if (_v) {
22900 {
22901 void *ptr = 0;
22902 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22903 _v = 0;
22904 PyErr_Clear();
22905 } else {
22906 _v = (ptr != 0);
22907 }
22908 }
22909 if (_v) {
22910 return _wrap_DateTime___add____SWIG_1(self,args);
22911 }
22912 }
22913 }
22914
22915 Py_INCREF(Py_NotImplemented);
22916 return Py_NotImplemented;
22917 }
22918
22919
22920 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22921 PyObject *resultobj;
22922 wxDateTime *arg1 = (wxDateTime *) 0 ;
22923 wxDateTime *arg2 = 0 ;
22924 wxTimeSpan result;
22925 PyObject * obj0 = 0 ;
22926 PyObject * obj1 = 0 ;
22927
22928 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22930 if (SWIG_arg_fail(1)) SWIG_fail;
22931 {
22932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22933 if (SWIG_arg_fail(2)) SWIG_fail;
22934 if (arg2 == NULL) {
22935 SWIG_null_ref("wxDateTime");
22936 }
22937 if (SWIG_arg_fail(2)) SWIG_fail;
22938 }
22939 {
22940 PyThreadState* __tstate = wxPyBeginAllowThreads();
22941 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22942
22943 wxPyEndAllowThreads(__tstate);
22944 if (PyErr_Occurred()) SWIG_fail;
22945 }
22946 {
22947 wxTimeSpan * resultptr;
22948 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22950 }
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22958 PyObject *resultobj;
22959 wxDateTime *arg1 = (wxDateTime *) 0 ;
22960 wxTimeSpan *arg2 = 0 ;
22961 wxDateTime result;
22962 PyObject * obj0 = 0 ;
22963 PyObject * obj1 = 0 ;
22964
22965 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22967 if (SWIG_arg_fail(1)) SWIG_fail;
22968 {
22969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22970 if (SWIG_arg_fail(2)) SWIG_fail;
22971 if (arg2 == NULL) {
22972 SWIG_null_ref("wxTimeSpan");
22973 }
22974 if (SWIG_arg_fail(2)) SWIG_fail;
22975 }
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22979
22980 wxPyEndAllowThreads(__tstate);
22981 if (PyErr_Occurred()) SWIG_fail;
22982 }
22983 {
22984 wxDateTime * resultptr;
22985 resultptr = new wxDateTime((wxDateTime &)(result));
22986 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22987 }
22988 return resultobj;
22989 fail:
22990 return NULL;
22991 }
22992
22993
22994 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22995 PyObject *resultobj;
22996 wxDateTime *arg1 = (wxDateTime *) 0 ;
22997 wxDateSpan *arg2 = 0 ;
22998 wxDateTime result;
22999 PyObject * obj0 = 0 ;
23000 PyObject * obj1 = 0 ;
23001
23002 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23004 if (SWIG_arg_fail(1)) SWIG_fail;
23005 {
23006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23007 if (SWIG_arg_fail(2)) SWIG_fail;
23008 if (arg2 == NULL) {
23009 SWIG_null_ref("wxDateSpan");
23010 }
23011 if (SWIG_arg_fail(2)) SWIG_fail;
23012 }
23013 {
23014 PyThreadState* __tstate = wxPyBeginAllowThreads();
23015 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23016
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 {
23021 wxDateTime * resultptr;
23022 resultptr = new wxDateTime((wxDateTime &)(result));
23023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23024 }
23025 return resultobj;
23026 fail:
23027 return NULL;
23028 }
23029
23030
23031 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23032 int argc;
23033 PyObject *argv[3];
23034 int ii;
23035
23036 argc = PyObject_Length(args);
23037 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23038 argv[ii] = PyTuple_GetItem(args,ii);
23039 }
23040 if (argc == 2) {
23041 int _v;
23042 {
23043 void *ptr;
23044 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23045 _v = 0;
23046 PyErr_Clear();
23047 } else {
23048 _v = 1;
23049 }
23050 }
23051 if (_v) {
23052 {
23053 void *ptr = 0;
23054 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23055 _v = 0;
23056 PyErr_Clear();
23057 } else {
23058 _v = (ptr != 0);
23059 }
23060 }
23061 if (_v) {
23062 return _wrap_DateTime___sub____SWIG_0(self,args);
23063 }
23064 }
23065 }
23066 if (argc == 2) {
23067 int _v;
23068 {
23069 void *ptr;
23070 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23071 _v = 0;
23072 PyErr_Clear();
23073 } else {
23074 _v = 1;
23075 }
23076 }
23077 if (_v) {
23078 {
23079 void *ptr = 0;
23080 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23081 _v = 0;
23082 PyErr_Clear();
23083 } else {
23084 _v = (ptr != 0);
23085 }
23086 }
23087 if (_v) {
23088 return _wrap_DateTime___sub____SWIG_1(self,args);
23089 }
23090 }
23091 }
23092 if (argc == 2) {
23093 int _v;
23094 {
23095 void *ptr;
23096 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23097 _v = 0;
23098 PyErr_Clear();
23099 } else {
23100 _v = 1;
23101 }
23102 }
23103 if (_v) {
23104 {
23105 void *ptr = 0;
23106 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23107 _v = 0;
23108 PyErr_Clear();
23109 } else {
23110 _v = (ptr != 0);
23111 }
23112 }
23113 if (_v) {
23114 return _wrap_DateTime___sub____SWIG_2(self,args);
23115 }
23116 }
23117 }
23118
23119 Py_INCREF(Py_NotImplemented);
23120 return Py_NotImplemented;
23121 }
23122
23123
23124 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23125 PyObject *resultobj;
23126 wxDateTime *arg1 = (wxDateTime *) 0 ;
23127 wxDateTime *arg2 = (wxDateTime *) 0 ;
23128 bool result;
23129 PyObject * obj0 = 0 ;
23130 PyObject * obj1 = 0 ;
23131 char *kwnames[] = {
23132 (char *) "self",(char *) "other", NULL
23133 };
23134
23135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23137 if (SWIG_arg_fail(1)) SWIG_fail;
23138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23139 if (SWIG_arg_fail(2)) SWIG_fail;
23140 {
23141 PyThreadState* __tstate = wxPyBeginAllowThreads();
23142 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23143
23144 wxPyEndAllowThreads(__tstate);
23145 if (PyErr_Occurred()) SWIG_fail;
23146 }
23147 {
23148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23149 }
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23157 PyObject *resultobj;
23158 wxDateTime *arg1 = (wxDateTime *) 0 ;
23159 wxDateTime *arg2 = (wxDateTime *) 0 ;
23160 bool result;
23161 PyObject * obj0 = 0 ;
23162 PyObject * obj1 = 0 ;
23163 char *kwnames[] = {
23164 (char *) "self",(char *) "other", NULL
23165 };
23166
23167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23169 if (SWIG_arg_fail(1)) SWIG_fail;
23170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(2)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 wxDateTime *arg1 = (wxDateTime *) 0 ;
23191 wxDateTime *arg2 = (wxDateTime *) 0 ;
23192 bool result;
23193 PyObject * obj0 = 0 ;
23194 PyObject * obj1 = 0 ;
23195 char *kwnames[] = {
23196 (char *) "self",(char *) "other", NULL
23197 };
23198
23199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23201 if (SWIG_arg_fail(1)) SWIG_fail;
23202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(2)) SWIG_fail;
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23207
23208 wxPyEndAllowThreads(__tstate);
23209 if (PyErr_Occurred()) SWIG_fail;
23210 }
23211 {
23212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23213 }
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj;
23222 wxDateTime *arg1 = (wxDateTime *) 0 ;
23223 wxDateTime *arg2 = (wxDateTime *) 0 ;
23224 bool result;
23225 PyObject * obj0 = 0 ;
23226 PyObject * obj1 = 0 ;
23227 char *kwnames[] = {
23228 (char *) "self",(char *) "other", NULL
23229 };
23230
23231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23233 if (SWIG_arg_fail(1)) SWIG_fail;
23234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23235 if (SWIG_arg_fail(2)) SWIG_fail;
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23239
23240 wxPyEndAllowThreads(__tstate);
23241 if (PyErr_Occurred()) SWIG_fail;
23242 }
23243 {
23244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23245 }
23246 return resultobj;
23247 fail:
23248 return NULL;
23249 }
23250
23251
23252 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23253 PyObject *resultobj;
23254 wxDateTime *arg1 = (wxDateTime *) 0 ;
23255 wxDateTime *arg2 = (wxDateTime *) 0 ;
23256 bool result;
23257 PyObject * obj0 = 0 ;
23258 PyObject * obj1 = 0 ;
23259 char *kwnames[] = {
23260 (char *) "self",(char *) "other", NULL
23261 };
23262
23263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23265 if (SWIG_arg_fail(1)) SWIG_fail;
23266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23267 if (SWIG_arg_fail(2)) SWIG_fail;
23268 {
23269 PyThreadState* __tstate = wxPyBeginAllowThreads();
23270 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23271
23272 wxPyEndAllowThreads(__tstate);
23273 if (PyErr_Occurred()) SWIG_fail;
23274 }
23275 {
23276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23277 }
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23285 PyObject *resultobj;
23286 wxDateTime *arg1 = (wxDateTime *) 0 ;
23287 wxDateTime *arg2 = (wxDateTime *) 0 ;
23288 bool result;
23289 PyObject * obj0 = 0 ;
23290 PyObject * obj1 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self",(char *) "other", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23299 if (SWIG_arg_fail(2)) SWIG_fail;
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23303
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 {
23308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23309 }
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj;
23318 wxDateTime *arg1 = (wxDateTime *) 0 ;
23319 wxString *arg2 = 0 ;
23320 int result;
23321 bool temp2 = false ;
23322 PyObject * obj0 = 0 ;
23323 PyObject * obj1 = 0 ;
23324 char *kwnames[] = {
23325 (char *) "self",(char *) "date", NULL
23326 };
23327
23328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23330 if (SWIG_arg_fail(1)) SWIG_fail;
23331 {
23332 arg2 = wxString_in_helper(obj1);
23333 if (arg2 == NULL) SWIG_fail;
23334 temp2 = true;
23335 }
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23339
23340 wxPyEndAllowThreads(__tstate);
23341 if (PyErr_Occurred()) SWIG_fail;
23342 }
23343 {
23344 resultobj = SWIG_From_int((int)(result));
23345 }
23346 {
23347 if (temp2)
23348 delete arg2;
23349 }
23350 return resultobj;
23351 fail:
23352 {
23353 if (temp2)
23354 delete arg2;
23355 }
23356 return NULL;
23357 }
23358
23359
23360 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23361 PyObject *resultobj;
23362 wxDateTime *arg1 = (wxDateTime *) 0 ;
23363 wxString *arg2 = 0 ;
23364 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23365 wxString *arg3 = (wxString *) &arg3_defvalue ;
23366 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23367 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23368 int result;
23369 bool temp2 = false ;
23370 bool temp3 = false ;
23371 PyObject * obj0 = 0 ;
23372 PyObject * obj1 = 0 ;
23373 PyObject * obj2 = 0 ;
23374 PyObject * obj3 = 0 ;
23375 char *kwnames[] = {
23376 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23377 };
23378
23379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23381 if (SWIG_arg_fail(1)) SWIG_fail;
23382 {
23383 arg2 = wxString_in_helper(obj1);
23384 if (arg2 == NULL) SWIG_fail;
23385 temp2 = true;
23386 }
23387 if (obj2) {
23388 {
23389 arg3 = wxString_in_helper(obj2);
23390 if (arg3 == NULL) SWIG_fail;
23391 temp3 = true;
23392 }
23393 }
23394 if (obj3) {
23395 {
23396 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23397 if (SWIG_arg_fail(4)) SWIG_fail;
23398 if (arg4 == NULL) {
23399 SWIG_null_ref("wxDateTime");
23400 }
23401 if (SWIG_arg_fail(4)) SWIG_fail;
23402 }
23403 }
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23407
23408 wxPyEndAllowThreads(__tstate);
23409 if (PyErr_Occurred()) SWIG_fail;
23410 }
23411 {
23412 resultobj = SWIG_From_int((int)(result));
23413 }
23414 {
23415 if (temp2)
23416 delete arg2;
23417 }
23418 {
23419 if (temp3)
23420 delete arg3;
23421 }
23422 return resultobj;
23423 fail:
23424 {
23425 if (temp2)
23426 delete arg2;
23427 }
23428 {
23429 if (temp3)
23430 delete arg3;
23431 }
23432 return NULL;
23433 }
23434
23435
23436 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23437 PyObject *resultobj;
23438 wxDateTime *arg1 = (wxDateTime *) 0 ;
23439 wxString *arg2 = 0 ;
23440 int result;
23441 bool temp2 = false ;
23442 PyObject * obj0 = 0 ;
23443 PyObject * obj1 = 0 ;
23444 char *kwnames[] = {
23445 (char *) "self",(char *) "datetime", NULL
23446 };
23447
23448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23450 if (SWIG_arg_fail(1)) SWIG_fail;
23451 {
23452 arg2 = wxString_in_helper(obj1);
23453 if (arg2 == NULL) SWIG_fail;
23454 temp2 = true;
23455 }
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23459
23460 wxPyEndAllowThreads(__tstate);
23461 if (PyErr_Occurred()) SWIG_fail;
23462 }
23463 {
23464 resultobj = SWIG_From_int((int)(result));
23465 }
23466 {
23467 if (temp2)
23468 delete arg2;
23469 }
23470 return resultobj;
23471 fail:
23472 {
23473 if (temp2)
23474 delete arg2;
23475 }
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxDateTime *arg1 = (wxDateTime *) 0 ;
23483 wxString *arg2 = 0 ;
23484 int result;
23485 bool temp2 = false ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char *kwnames[] = {
23489 (char *) "self",(char *) "date", NULL
23490 };
23491
23492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23494 if (SWIG_arg_fail(1)) SWIG_fail;
23495 {
23496 arg2 = wxString_in_helper(obj1);
23497 if (arg2 == NULL) SWIG_fail;
23498 temp2 = true;
23499 }
23500 {
23501 PyThreadState* __tstate = wxPyBeginAllowThreads();
23502 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23503
23504 wxPyEndAllowThreads(__tstate);
23505 if (PyErr_Occurred()) SWIG_fail;
23506 }
23507 {
23508 resultobj = SWIG_From_int((int)(result));
23509 }
23510 {
23511 if (temp2)
23512 delete arg2;
23513 }
23514 return resultobj;
23515 fail:
23516 {
23517 if (temp2)
23518 delete arg2;
23519 }
23520 return NULL;
23521 }
23522
23523
23524 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23525 PyObject *resultobj;
23526 wxDateTime *arg1 = (wxDateTime *) 0 ;
23527 wxString *arg2 = 0 ;
23528 int result;
23529 bool temp2 = false ;
23530 PyObject * obj0 = 0 ;
23531 PyObject * obj1 = 0 ;
23532 char *kwnames[] = {
23533 (char *) "self",(char *) "time", NULL
23534 };
23535
23536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23538 if (SWIG_arg_fail(1)) SWIG_fail;
23539 {
23540 arg2 = wxString_in_helper(obj1);
23541 if (arg2 == NULL) SWIG_fail;
23542 temp2 = true;
23543 }
23544 {
23545 PyThreadState* __tstate = wxPyBeginAllowThreads();
23546 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23547
23548 wxPyEndAllowThreads(__tstate);
23549 if (PyErr_Occurred()) SWIG_fail;
23550 }
23551 {
23552 resultobj = SWIG_From_int((int)(result));
23553 }
23554 {
23555 if (temp2)
23556 delete arg2;
23557 }
23558 return resultobj;
23559 fail:
23560 {
23561 if (temp2)
23562 delete arg2;
23563 }
23564 return NULL;
23565 }
23566
23567
23568 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23569 PyObject *resultobj;
23570 wxDateTime *arg1 = (wxDateTime *) 0 ;
23571 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23572 wxString *arg2 = (wxString *) &arg2_defvalue ;
23573 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23574 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23575 wxString result;
23576 bool temp2 = false ;
23577 bool temp3 = false ;
23578 PyObject * obj0 = 0 ;
23579 PyObject * obj1 = 0 ;
23580 PyObject * obj2 = 0 ;
23581 char *kwnames[] = {
23582 (char *) "self",(char *) "format",(char *) "tz", NULL
23583 };
23584
23585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23587 if (SWIG_arg_fail(1)) SWIG_fail;
23588 if (obj1) {
23589 {
23590 arg2 = wxString_in_helper(obj1);
23591 if (arg2 == NULL) SWIG_fail;
23592 temp2 = true;
23593 }
23594 }
23595 if (obj2) {
23596 {
23597 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23598 temp3 = true;
23599 }
23600 }
23601 {
23602 PyThreadState* __tstate = wxPyBeginAllowThreads();
23603 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23604
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 #if wxUSE_UNICODE
23610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23611 #else
23612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23613 #endif
23614 }
23615 {
23616 if (temp2)
23617 delete arg2;
23618 }
23619 {
23620 if (temp3) delete arg3;
23621 }
23622 return resultobj;
23623 fail:
23624 {
23625 if (temp2)
23626 delete arg2;
23627 }
23628 {
23629 if (temp3) delete arg3;
23630 }
23631 return NULL;
23632 }
23633
23634
23635 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23636 PyObject *resultobj;
23637 wxDateTime *arg1 = (wxDateTime *) 0 ;
23638 wxString result;
23639 PyObject * obj0 = 0 ;
23640 char *kwnames[] = {
23641 (char *) "self", NULL
23642 };
23643
23644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23646 if (SWIG_arg_fail(1)) SWIG_fail;
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = ((wxDateTime const *)arg1)->FormatDate();
23650
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 #if wxUSE_UNICODE
23656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23657 #else
23658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23659 #endif
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj;
23669 wxDateTime *arg1 = (wxDateTime *) 0 ;
23670 wxString result;
23671 PyObject * obj0 = 0 ;
23672 char *kwnames[] = {
23673 (char *) "self", NULL
23674 };
23675
23676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 result = ((wxDateTime const *)arg1)->FormatTime();
23682
23683 wxPyEndAllowThreads(__tstate);
23684 if (PyErr_Occurred()) SWIG_fail;
23685 }
23686 {
23687 #if wxUSE_UNICODE
23688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23689 #else
23690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23691 #endif
23692 }
23693 return resultobj;
23694 fail:
23695 return NULL;
23696 }
23697
23698
23699 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23700 PyObject *resultobj;
23701 wxDateTime *arg1 = (wxDateTime *) 0 ;
23702 wxString result;
23703 PyObject * obj0 = 0 ;
23704 char *kwnames[] = {
23705 (char *) "self", NULL
23706 };
23707
23708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23710 if (SWIG_arg_fail(1)) SWIG_fail;
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = ((wxDateTime const *)arg1)->FormatISODate();
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 {
23719 #if wxUSE_UNICODE
23720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23721 #else
23722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23723 #endif
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 wxDateTime *arg1 = (wxDateTime *) 0 ;
23734 wxString result;
23735 PyObject * obj0 = 0 ;
23736 char *kwnames[] = {
23737 (char *) "self", NULL
23738 };
23739
23740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23742 if (SWIG_arg_fail(1)) SWIG_fail;
23743 {
23744 PyThreadState* __tstate = wxPyBeginAllowThreads();
23745 result = ((wxDateTime const *)arg1)->FormatISOTime();
23746
23747 wxPyEndAllowThreads(__tstate);
23748 if (PyErr_Occurred()) SWIG_fail;
23749 }
23750 {
23751 #if wxUSE_UNICODE
23752 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23753 #else
23754 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23755 #endif
23756 }
23757 return resultobj;
23758 fail:
23759 return NULL;
23760 }
23761
23762
23763 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23764 PyObject *obj;
23765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23766 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23767 Py_INCREF(obj);
23768 return Py_BuildValue((char *)"");
23769 }
23770 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj;
23772 long arg1 ;
23773 wxTimeSpan result;
23774 PyObject * obj0 = 0 ;
23775 char *kwnames[] = {
23776 (char *) "sec", NULL
23777 };
23778
23779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23780 {
23781 arg1 = (long)(SWIG_As_long(obj0));
23782 if (SWIG_arg_fail(1)) SWIG_fail;
23783 }
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = wxTimeSpan::Seconds(arg1);
23787
23788 wxPyEndAllowThreads(__tstate);
23789 if (PyErr_Occurred()) SWIG_fail;
23790 }
23791 {
23792 wxTimeSpan * resultptr;
23793 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23795 }
23796 return resultobj;
23797 fail:
23798 return NULL;
23799 }
23800
23801
23802 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23803 PyObject *resultobj;
23804 wxTimeSpan result;
23805 char *kwnames[] = {
23806 NULL
23807 };
23808
23809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = wxTimeSpan::Second();
23813
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 {
23818 wxTimeSpan * resultptr;
23819 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23820 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23821 }
23822 return resultobj;
23823 fail:
23824 return NULL;
23825 }
23826
23827
23828 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23829 PyObject *resultobj;
23830 long arg1 ;
23831 wxTimeSpan result;
23832 PyObject * obj0 = 0 ;
23833 char *kwnames[] = {
23834 (char *) "min", NULL
23835 };
23836
23837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23838 {
23839 arg1 = (long)(SWIG_As_long(obj0));
23840 if (SWIG_arg_fail(1)) SWIG_fail;
23841 }
23842 {
23843 PyThreadState* __tstate = wxPyBeginAllowThreads();
23844 result = wxTimeSpan::Minutes(arg1);
23845
23846 wxPyEndAllowThreads(__tstate);
23847 if (PyErr_Occurred()) SWIG_fail;
23848 }
23849 {
23850 wxTimeSpan * resultptr;
23851 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23853 }
23854 return resultobj;
23855 fail:
23856 return NULL;
23857 }
23858
23859
23860 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23861 PyObject *resultobj;
23862 wxTimeSpan result;
23863 char *kwnames[] = {
23864 NULL
23865 };
23866
23867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 result = wxTimeSpan::Minute();
23871
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 {
23876 wxTimeSpan * resultptr;
23877 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23879 }
23880 return resultobj;
23881 fail:
23882 return NULL;
23883 }
23884
23885
23886 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23887 PyObject *resultobj;
23888 long arg1 ;
23889 wxTimeSpan result;
23890 PyObject * obj0 = 0 ;
23891 char *kwnames[] = {
23892 (char *) "hours", NULL
23893 };
23894
23895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23896 {
23897 arg1 = (long)(SWIG_As_long(obj0));
23898 if (SWIG_arg_fail(1)) SWIG_fail;
23899 }
23900 {
23901 PyThreadState* __tstate = wxPyBeginAllowThreads();
23902 result = wxTimeSpan::Hours(arg1);
23903
23904 wxPyEndAllowThreads(__tstate);
23905 if (PyErr_Occurred()) SWIG_fail;
23906 }
23907 {
23908 wxTimeSpan * resultptr;
23909 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23911 }
23912 return resultobj;
23913 fail:
23914 return NULL;
23915 }
23916
23917
23918 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23919 PyObject *resultobj;
23920 wxTimeSpan result;
23921 char *kwnames[] = {
23922 NULL
23923 };
23924
23925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 result = wxTimeSpan::Hour();
23929
23930 wxPyEndAllowThreads(__tstate);
23931 if (PyErr_Occurred()) SWIG_fail;
23932 }
23933 {
23934 wxTimeSpan * resultptr;
23935 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23937 }
23938 return resultobj;
23939 fail:
23940 return NULL;
23941 }
23942
23943
23944 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23945 PyObject *resultobj;
23946 long arg1 ;
23947 wxTimeSpan result;
23948 PyObject * obj0 = 0 ;
23949 char *kwnames[] = {
23950 (char *) "days", NULL
23951 };
23952
23953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23954 {
23955 arg1 = (long)(SWIG_As_long(obj0));
23956 if (SWIG_arg_fail(1)) SWIG_fail;
23957 }
23958 {
23959 PyThreadState* __tstate = wxPyBeginAllowThreads();
23960 result = wxTimeSpan::Days(arg1);
23961
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 {
23966 wxTimeSpan * resultptr;
23967 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23969 }
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23977 PyObject *resultobj;
23978 wxTimeSpan result;
23979 char *kwnames[] = {
23980 NULL
23981 };
23982
23983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 result = wxTimeSpan::Day();
23987
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 {
23992 wxTimeSpan * resultptr;
23993 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23995 }
23996 return resultobj;
23997 fail:
23998 return NULL;
23999 }
24000
24001
24002 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24003 PyObject *resultobj;
24004 long arg1 ;
24005 wxTimeSpan result;
24006 PyObject * obj0 = 0 ;
24007 char *kwnames[] = {
24008 (char *) "days", NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24012 {
24013 arg1 = (long)(SWIG_As_long(obj0));
24014 if (SWIG_arg_fail(1)) SWIG_fail;
24015 }
24016 {
24017 PyThreadState* __tstate = wxPyBeginAllowThreads();
24018 result = wxTimeSpan::Weeks(arg1);
24019
24020 wxPyEndAllowThreads(__tstate);
24021 if (PyErr_Occurred()) SWIG_fail;
24022 }
24023 {
24024 wxTimeSpan * resultptr;
24025 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj;
24036 wxTimeSpan result;
24037 char *kwnames[] = {
24038 NULL
24039 };
24040
24041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24042 {
24043 PyThreadState* __tstate = wxPyBeginAllowThreads();
24044 result = wxTimeSpan::Week();
24045
24046 wxPyEndAllowThreads(__tstate);
24047 if (PyErr_Occurred()) SWIG_fail;
24048 }
24049 {
24050 wxTimeSpan * resultptr;
24051 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24053 }
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 long arg1 = (long) 0 ;
24063 long arg2 = (long) 0 ;
24064 long arg3 = (long) 0 ;
24065 long arg4 = (long) 0 ;
24066 wxTimeSpan *result;
24067 PyObject * obj0 = 0 ;
24068 PyObject * obj1 = 0 ;
24069 PyObject * obj2 = 0 ;
24070 PyObject * obj3 = 0 ;
24071 char *kwnames[] = {
24072 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24073 };
24074
24075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24076 if (obj0) {
24077 {
24078 arg1 = (long)(SWIG_As_long(obj0));
24079 if (SWIG_arg_fail(1)) SWIG_fail;
24080 }
24081 }
24082 if (obj1) {
24083 {
24084 arg2 = (long)(SWIG_As_long(obj1));
24085 if (SWIG_arg_fail(2)) SWIG_fail;
24086 }
24087 }
24088 if (obj2) {
24089 {
24090 arg3 = (long)(SWIG_As_long(obj2));
24091 if (SWIG_arg_fail(3)) SWIG_fail;
24092 }
24093 }
24094 if (obj3) {
24095 {
24096 arg4 = (long)(SWIG_As_long(obj3));
24097 if (SWIG_arg_fail(4)) SWIG_fail;
24098 }
24099 }
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24103
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj;
24116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24117 PyObject * obj0 = 0 ;
24118 char *kwnames[] = {
24119 (char *) "self", NULL
24120 };
24121
24122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24124 if (SWIG_arg_fail(1)) SWIG_fail;
24125 {
24126 PyThreadState* __tstate = wxPyBeginAllowThreads();
24127 delete arg1;
24128
24129 wxPyEndAllowThreads(__tstate);
24130 if (PyErr_Occurred()) SWIG_fail;
24131 }
24132 Py_INCREF(Py_None); resultobj = Py_None;
24133 return resultobj;
24134 fail:
24135 return NULL;
24136 }
24137
24138
24139 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24140 PyObject *resultobj;
24141 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24142 wxTimeSpan *arg2 = 0 ;
24143 wxTimeSpan *result;
24144 PyObject * obj0 = 0 ;
24145 PyObject * obj1 = 0 ;
24146 char *kwnames[] = {
24147 (char *) "self",(char *) "diff", NULL
24148 };
24149
24150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24152 if (SWIG_arg_fail(1)) SWIG_fail;
24153 {
24154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24155 if (SWIG_arg_fail(2)) SWIG_fail;
24156 if (arg2 == NULL) {
24157 SWIG_null_ref("wxTimeSpan");
24158 }
24159 if (SWIG_arg_fail(2)) SWIG_fail;
24160 }
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 {
24164 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24165 result = (wxTimeSpan *) &_result_ref;
24166 }
24167
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24179 PyObject *resultobj;
24180 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24181 wxTimeSpan *arg2 = 0 ;
24182 wxTimeSpan *result;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185 char *kwnames[] = {
24186 (char *) "self",(char *) "diff", NULL
24187 };
24188
24189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24191 if (SWIG_arg_fail(1)) SWIG_fail;
24192 {
24193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24194 if (SWIG_arg_fail(2)) SWIG_fail;
24195 if (arg2 == NULL) {
24196 SWIG_null_ref("wxTimeSpan");
24197 }
24198 if (SWIG_arg_fail(2)) SWIG_fail;
24199 }
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 {
24203 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24204 result = (wxTimeSpan *) &_result_ref;
24205 }
24206
24207 wxPyEndAllowThreads(__tstate);
24208 if (PyErr_Occurred()) SWIG_fail;
24209 }
24210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24211 return resultobj;
24212 fail:
24213 return NULL;
24214 }
24215
24216
24217 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24218 PyObject *resultobj;
24219 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24220 int arg2 ;
24221 wxTimeSpan *result;
24222 PyObject * obj0 = 0 ;
24223 PyObject * obj1 = 0 ;
24224 char *kwnames[] = {
24225 (char *) "self",(char *) "n", NULL
24226 };
24227
24228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24230 if (SWIG_arg_fail(1)) SWIG_fail;
24231 {
24232 arg2 = (int)(SWIG_As_int(obj1));
24233 if (SWIG_arg_fail(2)) SWIG_fail;
24234 }
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 {
24238 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24239 result = (wxTimeSpan *) &_result_ref;
24240 }
24241
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj;
24254 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24255 wxTimeSpan *result;
24256 PyObject * obj0 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 {
24267 wxTimeSpan &_result_ref = (arg1)->Neg();
24268 result = (wxTimeSpan *) &_result_ref;
24269 }
24270
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24282 PyObject *resultobj;
24283 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24284 wxTimeSpan result;
24285 PyObject * obj0 = 0 ;
24286 char *kwnames[] = {
24287 (char *) "self", NULL
24288 };
24289
24290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24292 if (SWIG_arg_fail(1)) SWIG_fail;
24293 {
24294 PyThreadState* __tstate = wxPyBeginAllowThreads();
24295 result = ((wxTimeSpan const *)arg1)->Abs();
24296
24297 wxPyEndAllowThreads(__tstate);
24298 if (PyErr_Occurred()) SWIG_fail;
24299 }
24300 {
24301 wxTimeSpan * resultptr;
24302 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24303 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj;
24313 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24314 wxTimeSpan *arg2 = 0 ;
24315 wxTimeSpan *result;
24316 PyObject * obj0 = 0 ;
24317 PyObject * obj1 = 0 ;
24318 char *kwnames[] = {
24319 (char *) "self",(char *) "diff", NULL
24320 };
24321
24322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24324 if (SWIG_arg_fail(1)) SWIG_fail;
24325 {
24326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24327 if (SWIG_arg_fail(2)) SWIG_fail;
24328 if (arg2 == NULL) {
24329 SWIG_null_ref("wxTimeSpan");
24330 }
24331 if (SWIG_arg_fail(2)) SWIG_fail;
24332 }
24333 {
24334 PyThreadState* __tstate = wxPyBeginAllowThreads();
24335 {
24336 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24337 result = (wxTimeSpan *) &_result_ref;
24338 }
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj;
24352 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24353 wxTimeSpan *arg2 = 0 ;
24354 wxTimeSpan *result;
24355 PyObject * obj0 = 0 ;
24356 PyObject * obj1 = 0 ;
24357 char *kwnames[] = {
24358 (char *) "self",(char *) "diff", NULL
24359 };
24360
24361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24363 if (SWIG_arg_fail(1)) SWIG_fail;
24364 {
24365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24366 if (SWIG_arg_fail(2)) SWIG_fail;
24367 if (arg2 == NULL) {
24368 SWIG_null_ref("wxTimeSpan");
24369 }
24370 if (SWIG_arg_fail(2)) SWIG_fail;
24371 }
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 {
24375 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24376 result = (wxTimeSpan *) &_result_ref;
24377 }
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj;
24391 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24392 int arg2 ;
24393 wxTimeSpan *result;
24394 PyObject * obj0 = 0 ;
24395 PyObject * obj1 = 0 ;
24396 char *kwnames[] = {
24397 (char *) "self",(char *) "n", NULL
24398 };
24399
24400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24402 if (SWIG_arg_fail(1)) SWIG_fail;
24403 {
24404 arg2 = (int)(SWIG_As_int(obj1));
24405 if (SWIG_arg_fail(2)) SWIG_fail;
24406 }
24407 {
24408 PyThreadState* __tstate = wxPyBeginAllowThreads();
24409 {
24410 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24411 result = (wxTimeSpan *) &_result_ref;
24412 }
24413
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24425 PyObject *resultobj;
24426 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24427 wxTimeSpan *result;
24428 PyObject * obj0 = 0 ;
24429 char *kwnames[] = {
24430 (char *) "self", NULL
24431 };
24432
24433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24435 if (SWIG_arg_fail(1)) SWIG_fail;
24436 {
24437 PyThreadState* __tstate = wxPyBeginAllowThreads();
24438 {
24439 wxTimeSpan &_result_ref = (arg1)->operator -();
24440 result = (wxTimeSpan *) &_result_ref;
24441 }
24442
24443 wxPyEndAllowThreads(__tstate);
24444 if (PyErr_Occurred()) SWIG_fail;
24445 }
24446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24454 PyObject *resultobj;
24455 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24456 wxTimeSpan *arg2 = 0 ;
24457 wxTimeSpan result;
24458 PyObject * obj0 = 0 ;
24459 PyObject * obj1 = 0 ;
24460 char *kwnames[] = {
24461 (char *) "self",(char *) "other", NULL
24462 };
24463
24464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24466 if (SWIG_arg_fail(1)) SWIG_fail;
24467 {
24468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24469 if (SWIG_arg_fail(2)) SWIG_fail;
24470 if (arg2 == NULL) {
24471 SWIG_null_ref("wxTimeSpan");
24472 }
24473 if (SWIG_arg_fail(2)) SWIG_fail;
24474 }
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 wxTimeSpan * resultptr;
24484 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24486 }
24487 return resultobj;
24488 fail:
24489 return NULL;
24490 }
24491
24492
24493 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24494 PyObject *resultobj;
24495 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24496 wxTimeSpan *arg2 = 0 ;
24497 wxTimeSpan result;
24498 PyObject * obj0 = 0 ;
24499 PyObject * obj1 = 0 ;
24500 char *kwnames[] = {
24501 (char *) "self",(char *) "other", NULL
24502 };
24503
24504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(1)) SWIG_fail;
24507 {
24508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24509 if (SWIG_arg_fail(2)) SWIG_fail;
24510 if (arg2 == NULL) {
24511 SWIG_null_ref("wxTimeSpan");
24512 }
24513 if (SWIG_arg_fail(2)) SWIG_fail;
24514 }
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24518
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 {
24523 wxTimeSpan * resultptr;
24524 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24526 }
24527 return resultobj;
24528 fail:
24529 return NULL;
24530 }
24531
24532
24533 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24534 PyObject *resultobj;
24535 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24536 int arg2 ;
24537 wxTimeSpan result;
24538 PyObject * obj0 = 0 ;
24539 PyObject * obj1 = 0 ;
24540 char *kwnames[] = {
24541 (char *) "self",(char *) "n", NULL
24542 };
24543
24544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24546 if (SWIG_arg_fail(1)) SWIG_fail;
24547 {
24548 arg2 = (int)(SWIG_As_int(obj1));
24549 if (SWIG_arg_fail(2)) SWIG_fail;
24550 }
24551 {
24552 PyThreadState* __tstate = wxPyBeginAllowThreads();
24553 result = wxTimeSpan___mul__(arg1,arg2);
24554
24555 wxPyEndAllowThreads(__tstate);
24556 if (PyErr_Occurred()) SWIG_fail;
24557 }
24558 {
24559 wxTimeSpan * resultptr;
24560 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24562 }
24563 return resultobj;
24564 fail:
24565 return NULL;
24566 }
24567
24568
24569 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj;
24571 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24572 int arg2 ;
24573 wxTimeSpan result;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char *kwnames[] = {
24577 (char *) "self",(char *) "n", NULL
24578 };
24579
24580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24582 if (SWIG_arg_fail(1)) SWIG_fail;
24583 {
24584 arg2 = (int)(SWIG_As_int(obj1));
24585 if (SWIG_arg_fail(2)) SWIG_fail;
24586 }
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 result = wxTimeSpan___rmul__(arg1,arg2);
24590
24591 wxPyEndAllowThreads(__tstate);
24592 if (PyErr_Occurred()) SWIG_fail;
24593 }
24594 {
24595 wxTimeSpan * resultptr;
24596 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24598 }
24599 return resultobj;
24600 fail:
24601 return NULL;
24602 }
24603
24604
24605 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24606 PyObject *resultobj;
24607 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24608 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24609 bool result;
24610 PyObject * obj0 = 0 ;
24611 PyObject * obj1 = 0 ;
24612 char *kwnames[] = {
24613 (char *) "self",(char *) "other", NULL
24614 };
24615
24616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24618 if (SWIG_arg_fail(1)) SWIG_fail;
24619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24620 if (SWIG_arg_fail(2)) SWIG_fail;
24621 {
24622 PyThreadState* __tstate = wxPyBeginAllowThreads();
24623 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24624
24625 wxPyEndAllowThreads(__tstate);
24626 if (PyErr_Occurred()) SWIG_fail;
24627 }
24628 {
24629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24630 }
24631 return resultobj;
24632 fail:
24633 return NULL;
24634 }
24635
24636
24637 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24638 PyObject *resultobj;
24639 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24640 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24641 bool result;
24642 PyObject * obj0 = 0 ;
24643 PyObject * obj1 = 0 ;
24644 char *kwnames[] = {
24645 (char *) "self",(char *) "other", NULL
24646 };
24647
24648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24650 if (SWIG_arg_fail(1)) SWIG_fail;
24651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(2)) SWIG_fail;
24653 {
24654 PyThreadState* __tstate = wxPyBeginAllowThreads();
24655 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24656
24657 wxPyEndAllowThreads(__tstate);
24658 if (PyErr_Occurred()) SWIG_fail;
24659 }
24660 {
24661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24662 }
24663 return resultobj;
24664 fail:
24665 return NULL;
24666 }
24667
24668
24669 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24670 PyObject *resultobj;
24671 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24672 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24673 bool result;
24674 PyObject * obj0 = 0 ;
24675 PyObject * obj1 = 0 ;
24676 char *kwnames[] = {
24677 (char *) "self",(char *) "other", NULL
24678 };
24679
24680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24682 if (SWIG_arg_fail(1)) SWIG_fail;
24683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(2)) SWIG_fail;
24685 {
24686 PyThreadState* __tstate = wxPyBeginAllowThreads();
24687 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24688
24689 wxPyEndAllowThreads(__tstate);
24690 if (PyErr_Occurred()) SWIG_fail;
24691 }
24692 {
24693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24694 }
24695 return resultobj;
24696 fail:
24697 return NULL;
24698 }
24699
24700
24701 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24702 PyObject *resultobj;
24703 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24704 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24705 bool result;
24706 PyObject * obj0 = 0 ;
24707 PyObject * obj1 = 0 ;
24708 char *kwnames[] = {
24709 (char *) "self",(char *) "other", NULL
24710 };
24711
24712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24714 if (SWIG_arg_fail(1)) SWIG_fail;
24715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24716 if (SWIG_arg_fail(2)) SWIG_fail;
24717 {
24718 PyThreadState* __tstate = wxPyBeginAllowThreads();
24719 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24720
24721 wxPyEndAllowThreads(__tstate);
24722 if (PyErr_Occurred()) SWIG_fail;
24723 }
24724 {
24725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24726 }
24727 return resultobj;
24728 fail:
24729 return NULL;
24730 }
24731
24732
24733 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24734 PyObject *resultobj;
24735 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24736 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24737 bool result;
24738 PyObject * obj0 = 0 ;
24739 PyObject * obj1 = 0 ;
24740 char *kwnames[] = {
24741 (char *) "self",(char *) "other", NULL
24742 };
24743
24744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24746 if (SWIG_arg_fail(1)) SWIG_fail;
24747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24748 if (SWIG_arg_fail(2)) SWIG_fail;
24749 {
24750 PyThreadState* __tstate = wxPyBeginAllowThreads();
24751 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24752
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 {
24757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24758 }
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24766 PyObject *resultobj;
24767 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24768 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24769 bool result;
24770 PyObject * obj0 = 0 ;
24771 PyObject * obj1 = 0 ;
24772 char *kwnames[] = {
24773 (char *) "self",(char *) "other", NULL
24774 };
24775
24776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24778 if (SWIG_arg_fail(1)) SWIG_fail;
24779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24780 if (SWIG_arg_fail(2)) SWIG_fail;
24781 {
24782 PyThreadState* __tstate = wxPyBeginAllowThreads();
24783 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24784
24785 wxPyEndAllowThreads(__tstate);
24786 if (PyErr_Occurred()) SWIG_fail;
24787 }
24788 {
24789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24790 }
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24798 PyObject *resultobj;
24799 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24800 bool result;
24801 PyObject * obj0 = 0 ;
24802 char *kwnames[] = {
24803 (char *) "self", NULL
24804 };
24805
24806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24808 if (SWIG_arg_fail(1)) SWIG_fail;
24809 {
24810 PyThreadState* __tstate = wxPyBeginAllowThreads();
24811 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24812
24813 wxPyEndAllowThreads(__tstate);
24814 if (PyErr_Occurred()) SWIG_fail;
24815 }
24816 {
24817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24818 }
24819 return resultobj;
24820 fail:
24821 return NULL;
24822 }
24823
24824
24825 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24826 PyObject *resultobj;
24827 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24828 bool result;
24829 PyObject * obj0 = 0 ;
24830 char *kwnames[] = {
24831 (char *) "self", NULL
24832 };
24833
24834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24836 if (SWIG_arg_fail(1)) SWIG_fail;
24837 {
24838 PyThreadState* __tstate = wxPyBeginAllowThreads();
24839 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24840
24841 wxPyEndAllowThreads(__tstate);
24842 if (PyErr_Occurred()) SWIG_fail;
24843 }
24844 {
24845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24846 }
24847 return resultobj;
24848 fail:
24849 return NULL;
24850 }
24851
24852
24853 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24854 PyObject *resultobj;
24855 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24856 bool result;
24857 PyObject * obj0 = 0 ;
24858 char *kwnames[] = {
24859 (char *) "self", NULL
24860 };
24861
24862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24864 if (SWIG_arg_fail(1)) SWIG_fail;
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24868
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 {
24873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24874 }
24875 return resultobj;
24876 fail:
24877 return NULL;
24878 }
24879
24880
24881 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24882 PyObject *resultobj;
24883 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24884 wxTimeSpan *arg2 = 0 ;
24885 bool result;
24886 PyObject * obj0 = 0 ;
24887 PyObject * obj1 = 0 ;
24888 char *kwnames[] = {
24889 (char *) "self",(char *) "ts", NULL
24890 };
24891
24892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 {
24896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24897 if (SWIG_arg_fail(2)) SWIG_fail;
24898 if (arg2 == NULL) {
24899 SWIG_null_ref("wxTimeSpan");
24900 }
24901 if (SWIG_arg_fail(2)) SWIG_fail;
24902 }
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24906
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24912 }
24913 return resultobj;
24914 fail:
24915 return NULL;
24916 }
24917
24918
24919 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24920 PyObject *resultobj;
24921 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24922 wxTimeSpan *arg2 = 0 ;
24923 bool result;
24924 PyObject * obj0 = 0 ;
24925 PyObject * obj1 = 0 ;
24926 char *kwnames[] = {
24927 (char *) "self",(char *) "ts", NULL
24928 };
24929
24930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24932 if (SWIG_arg_fail(1)) SWIG_fail;
24933 {
24934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24935 if (SWIG_arg_fail(2)) SWIG_fail;
24936 if (arg2 == NULL) {
24937 SWIG_null_ref("wxTimeSpan");
24938 }
24939 if (SWIG_arg_fail(2)) SWIG_fail;
24940 }
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24944
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24950 }
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj;
24959 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24960 wxTimeSpan *arg2 = 0 ;
24961 bool result;
24962 PyObject * obj0 = 0 ;
24963 PyObject * obj1 = 0 ;
24964 char *kwnames[] = {
24965 (char *) "self",(char *) "t", NULL
24966 };
24967
24968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24970 if (SWIG_arg_fail(1)) SWIG_fail;
24971 {
24972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24973 if (SWIG_arg_fail(2)) SWIG_fail;
24974 if (arg2 == NULL) {
24975 SWIG_null_ref("wxTimeSpan");
24976 }
24977 if (SWIG_arg_fail(2)) SWIG_fail;
24978 }
24979 {
24980 PyThreadState* __tstate = wxPyBeginAllowThreads();
24981 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24982
24983 wxPyEndAllowThreads(__tstate);
24984 if (PyErr_Occurred()) SWIG_fail;
24985 }
24986 {
24987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24988 }
24989 return resultobj;
24990 fail:
24991 return NULL;
24992 }
24993
24994
24995 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24996 PyObject *resultobj;
24997 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24998 int result;
24999 PyObject * obj0 = 0 ;
25000 char *kwnames[] = {
25001 (char *) "self", NULL
25002 };
25003
25004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) 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 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25010
25011 wxPyEndAllowThreads(__tstate);
25012 if (PyErr_Occurred()) SWIG_fail;
25013 }
25014 {
25015 resultobj = SWIG_From_int((int)(result));
25016 }
25017 return resultobj;
25018 fail:
25019 return NULL;
25020 }
25021
25022
25023 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25024 PyObject *resultobj;
25025 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25026 int result;
25027 PyObject * obj0 = 0 ;
25028 char *kwnames[] = {
25029 (char *) "self", NULL
25030 };
25031
25032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25034 if (SWIG_arg_fail(1)) SWIG_fail;
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25038
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 {
25043 resultobj = SWIG_From_int((int)(result));
25044 }
25045 return resultobj;
25046 fail:
25047 return NULL;
25048 }
25049
25050
25051 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25052 PyObject *resultobj;
25053 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25054 int result;
25055 PyObject * obj0 = 0 ;
25056 char *kwnames[] = {
25057 (char *) "self", NULL
25058 };
25059
25060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25062 if (SWIG_arg_fail(1)) SWIG_fail;
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25066
25067 wxPyEndAllowThreads(__tstate);
25068 if (PyErr_Occurred()) SWIG_fail;
25069 }
25070 {
25071 resultobj = SWIG_From_int((int)(result));
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25080 PyObject *resultobj;
25081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25082 int result;
25083 PyObject * obj0 = 0 ;
25084 char *kwnames[] = {
25085 (char *) "self", NULL
25086 };
25087
25088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25090 if (SWIG_arg_fail(1)) SWIG_fail;
25091 {
25092 PyThreadState* __tstate = wxPyBeginAllowThreads();
25093 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25094
25095 wxPyEndAllowThreads(__tstate);
25096 if (PyErr_Occurred()) SWIG_fail;
25097 }
25098 {
25099 resultobj = SWIG_From_int((int)(result));
25100 }
25101 return resultobj;
25102 fail:
25103 return NULL;
25104 }
25105
25106
25107 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj;
25109 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25110 wxLongLong result;
25111 PyObject * obj0 = 0 ;
25112 char *kwnames[] = {
25113 (char *) "self", NULL
25114 };
25115
25116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25118 if (SWIG_arg_fail(1)) SWIG_fail;
25119 {
25120 PyThreadState* __tstate = wxPyBeginAllowThreads();
25121 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25122
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 {
25127 PyObject *hi, *lo, *shifter, *shifted;
25128 hi = PyLong_FromLong( (&result)->GetHi() );
25129 lo = PyLong_FromLong( (&result)->GetLo() );
25130 shifter = PyLong_FromLong(32);
25131 shifted = PyNumber_Lshift(hi, shifter);
25132 resultobj = PyNumber_Or(shifted, lo);
25133 Py_DECREF(hi);
25134 Py_DECREF(lo);
25135 Py_DECREF(shifter);
25136 Py_DECREF(shifted);
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj;
25146 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25147 wxLongLong result;
25148 PyObject * obj0 = 0 ;
25149 char *kwnames[] = {
25150 (char *) "self", NULL
25151 };
25152
25153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25155 if (SWIG_arg_fail(1)) SWIG_fail;
25156 {
25157 PyThreadState* __tstate = wxPyBeginAllowThreads();
25158 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25159
25160 wxPyEndAllowThreads(__tstate);
25161 if (PyErr_Occurred()) SWIG_fail;
25162 }
25163 {
25164 PyObject *hi, *lo, *shifter, *shifted;
25165 hi = PyLong_FromLong( (&result)->GetHi() );
25166 lo = PyLong_FromLong( (&result)->GetLo() );
25167 shifter = PyLong_FromLong(32);
25168 shifted = PyNumber_Lshift(hi, shifter);
25169 resultobj = PyNumber_Or(shifted, lo);
25170 Py_DECREF(hi);
25171 Py_DECREF(lo);
25172 Py_DECREF(shifter);
25173 Py_DECREF(shifted);
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25182 PyObject *resultobj;
25183 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25184 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25185 wxString *arg2 = (wxString *) &arg2_defvalue ;
25186 wxString result;
25187 bool temp2 = false ;
25188 PyObject * obj0 = 0 ;
25189 PyObject * obj1 = 0 ;
25190 char *kwnames[] = {
25191 (char *) "self",(char *) "format", NULL
25192 };
25193
25194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25196 if (SWIG_arg_fail(1)) SWIG_fail;
25197 if (obj1) {
25198 {
25199 arg2 = wxString_in_helper(obj1);
25200 if (arg2 == NULL) SWIG_fail;
25201 temp2 = true;
25202 }
25203 }
25204 {
25205 PyThreadState* __tstate = wxPyBeginAllowThreads();
25206 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25207
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 {
25212 #if wxUSE_UNICODE
25213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25214 #else
25215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25216 #endif
25217 }
25218 {
25219 if (temp2)
25220 delete arg2;
25221 }
25222 return resultobj;
25223 fail:
25224 {
25225 if (temp2)
25226 delete arg2;
25227 }
25228 return NULL;
25229 }
25230
25231
25232 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25233 PyObject *obj;
25234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25235 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25236 Py_INCREF(obj);
25237 return Py_BuildValue((char *)"");
25238 }
25239 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj;
25241 int arg1 = (int) 0 ;
25242 int arg2 = (int) 0 ;
25243 int arg3 = (int) 0 ;
25244 int arg4 = (int) 0 ;
25245 wxDateSpan *result;
25246 PyObject * obj0 = 0 ;
25247 PyObject * obj1 = 0 ;
25248 PyObject * obj2 = 0 ;
25249 PyObject * obj3 = 0 ;
25250 char *kwnames[] = {
25251 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25252 };
25253
25254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25255 if (obj0) {
25256 {
25257 arg1 = (int)(SWIG_As_int(obj0));
25258 if (SWIG_arg_fail(1)) SWIG_fail;
25259 }
25260 }
25261 if (obj1) {
25262 {
25263 arg2 = (int)(SWIG_As_int(obj1));
25264 if (SWIG_arg_fail(2)) SWIG_fail;
25265 }
25266 }
25267 if (obj2) {
25268 {
25269 arg3 = (int)(SWIG_As_int(obj2));
25270 if (SWIG_arg_fail(3)) SWIG_fail;
25271 }
25272 }
25273 if (obj3) {
25274 {
25275 arg4 = (int)(SWIG_As_int(obj3));
25276 if (SWIG_arg_fail(4)) SWIG_fail;
25277 }
25278 }
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25282
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25287 return resultobj;
25288 fail:
25289 return NULL;
25290 }
25291
25292
25293 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25294 PyObject *resultobj;
25295 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25296 PyObject * obj0 = 0 ;
25297 char *kwnames[] = {
25298 (char *) "self", NULL
25299 };
25300
25301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25303 if (SWIG_arg_fail(1)) SWIG_fail;
25304 {
25305 PyThreadState* __tstate = wxPyBeginAllowThreads();
25306 delete arg1;
25307
25308 wxPyEndAllowThreads(__tstate);
25309 if (PyErr_Occurred()) SWIG_fail;
25310 }
25311 Py_INCREF(Py_None); resultobj = Py_None;
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25319 PyObject *resultobj;
25320 int arg1 ;
25321 wxDateSpan result;
25322 PyObject * obj0 = 0 ;
25323 char *kwnames[] = {
25324 (char *) "days", NULL
25325 };
25326
25327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25328 {
25329 arg1 = (int)(SWIG_As_int(obj0));
25330 if (SWIG_arg_fail(1)) SWIG_fail;
25331 }
25332 {
25333 PyThreadState* __tstate = wxPyBeginAllowThreads();
25334 result = wxDateSpan::Days(arg1);
25335
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 {
25340 wxDateSpan * resultptr;
25341 resultptr = new wxDateSpan((wxDateSpan &)(result));
25342 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25343 }
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj;
25352 wxDateSpan result;
25353 char *kwnames[] = {
25354 NULL
25355 };
25356
25357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 result = wxDateSpan::Day();
25361
25362 wxPyEndAllowThreads(__tstate);
25363 if (PyErr_Occurred()) SWIG_fail;
25364 }
25365 {
25366 wxDateSpan * resultptr;
25367 resultptr = new wxDateSpan((wxDateSpan &)(result));
25368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25369 }
25370 return resultobj;
25371 fail:
25372 return NULL;
25373 }
25374
25375
25376 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25377 PyObject *resultobj;
25378 int arg1 ;
25379 wxDateSpan result;
25380 PyObject * obj0 = 0 ;
25381 char *kwnames[] = {
25382 (char *) "weeks", NULL
25383 };
25384
25385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25386 {
25387 arg1 = (int)(SWIG_As_int(obj0));
25388 if (SWIG_arg_fail(1)) SWIG_fail;
25389 }
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 result = wxDateSpan::Weeks(arg1);
25393
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 {
25398 wxDateSpan * resultptr;
25399 resultptr = new wxDateSpan((wxDateSpan &)(result));
25400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25401 }
25402 return resultobj;
25403 fail:
25404 return NULL;
25405 }
25406
25407
25408 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25409 PyObject *resultobj;
25410 wxDateSpan result;
25411 char *kwnames[] = {
25412 NULL
25413 };
25414
25415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 result = wxDateSpan::Week();
25419
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 {
25424 wxDateSpan * resultptr;
25425 resultptr = new wxDateSpan((wxDateSpan &)(result));
25426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25427 }
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25435 PyObject *resultobj;
25436 int arg1 ;
25437 wxDateSpan result;
25438 PyObject * obj0 = 0 ;
25439 char *kwnames[] = {
25440 (char *) "mon", NULL
25441 };
25442
25443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25444 {
25445 arg1 = (int)(SWIG_As_int(obj0));
25446 if (SWIG_arg_fail(1)) SWIG_fail;
25447 }
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 result = wxDateSpan::Months(arg1);
25451
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 {
25456 wxDateSpan * resultptr;
25457 resultptr = new wxDateSpan((wxDateSpan &)(result));
25458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25459 }
25460 return resultobj;
25461 fail:
25462 return NULL;
25463 }
25464
25465
25466 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj;
25468 wxDateSpan result;
25469 char *kwnames[] = {
25470 NULL
25471 };
25472
25473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25474 {
25475 PyThreadState* __tstate = wxPyBeginAllowThreads();
25476 result = wxDateSpan::Month();
25477
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 {
25482 wxDateSpan * resultptr;
25483 resultptr = new wxDateSpan((wxDateSpan &)(result));
25484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25485 }
25486 return resultobj;
25487 fail:
25488 return NULL;
25489 }
25490
25491
25492 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25493 PyObject *resultobj;
25494 int arg1 ;
25495 wxDateSpan result;
25496 PyObject * obj0 = 0 ;
25497 char *kwnames[] = {
25498 (char *) "years", NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25502 {
25503 arg1 = (int)(SWIG_As_int(obj0));
25504 if (SWIG_arg_fail(1)) SWIG_fail;
25505 }
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 result = wxDateSpan::Years(arg1);
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 {
25514 wxDateSpan * resultptr;
25515 resultptr = new wxDateSpan((wxDateSpan &)(result));
25516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25517 }
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj;
25526 wxDateSpan result;
25527 char *kwnames[] = {
25528 NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 result = wxDateSpan::Year();
25535
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 {
25540 wxDateSpan * resultptr;
25541 resultptr = new wxDateSpan((wxDateSpan &)(result));
25542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25543 }
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25551 PyObject *resultobj;
25552 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25553 int arg2 ;
25554 wxDateSpan *result;
25555 PyObject * obj0 = 0 ;
25556 PyObject * obj1 = 0 ;
25557 char *kwnames[] = {
25558 (char *) "self",(char *) "n", NULL
25559 };
25560
25561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25563 if (SWIG_arg_fail(1)) SWIG_fail;
25564 {
25565 arg2 = (int)(SWIG_As_int(obj1));
25566 if (SWIG_arg_fail(2)) SWIG_fail;
25567 }
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 {
25571 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25572 result = (wxDateSpan *) &_result_ref;
25573 }
25574
25575 wxPyEndAllowThreads(__tstate);
25576 if (PyErr_Occurred()) SWIG_fail;
25577 }
25578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25586 PyObject *resultobj;
25587 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25588 int arg2 ;
25589 wxDateSpan *result;
25590 PyObject * obj0 = 0 ;
25591 PyObject * obj1 = 0 ;
25592 char *kwnames[] = {
25593 (char *) "self",(char *) "n", NULL
25594 };
25595
25596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25598 if (SWIG_arg_fail(1)) SWIG_fail;
25599 {
25600 arg2 = (int)(SWIG_As_int(obj1));
25601 if (SWIG_arg_fail(2)) SWIG_fail;
25602 }
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 {
25606 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25607 result = (wxDateSpan *) &_result_ref;
25608 }
25609
25610 wxPyEndAllowThreads(__tstate);
25611 if (PyErr_Occurred()) SWIG_fail;
25612 }
25613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25614 return resultobj;
25615 fail:
25616 return NULL;
25617 }
25618
25619
25620 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25621 PyObject *resultobj;
25622 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25623 int arg2 ;
25624 wxDateSpan *result;
25625 PyObject * obj0 = 0 ;
25626 PyObject * obj1 = 0 ;
25627 char *kwnames[] = {
25628 (char *) "self",(char *) "n", NULL
25629 };
25630
25631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25633 if (SWIG_arg_fail(1)) SWIG_fail;
25634 {
25635 arg2 = (int)(SWIG_As_int(obj1));
25636 if (SWIG_arg_fail(2)) SWIG_fail;
25637 }
25638 {
25639 PyThreadState* __tstate = wxPyBeginAllowThreads();
25640 {
25641 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25642 result = (wxDateSpan *) &_result_ref;
25643 }
25644
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25656 PyObject *resultobj;
25657 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25658 int arg2 ;
25659 wxDateSpan *result;
25660 PyObject * obj0 = 0 ;
25661 PyObject * obj1 = 0 ;
25662 char *kwnames[] = {
25663 (char *) "self",(char *) "n", NULL
25664 };
25665
25666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25668 if (SWIG_arg_fail(1)) SWIG_fail;
25669 {
25670 arg2 = (int)(SWIG_As_int(obj1));
25671 if (SWIG_arg_fail(2)) SWIG_fail;
25672 }
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 {
25676 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25677 result = (wxDateSpan *) &_result_ref;
25678 }
25679
25680 wxPyEndAllowThreads(__tstate);
25681 if (PyErr_Occurred()) SWIG_fail;
25682 }
25683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25684 return resultobj;
25685 fail:
25686 return NULL;
25687 }
25688
25689
25690 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25691 PyObject *resultobj;
25692 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25693 int result;
25694 PyObject * obj0 = 0 ;
25695 char *kwnames[] = {
25696 (char *) "self", NULL
25697 };
25698
25699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25701 if (SWIG_arg_fail(1)) SWIG_fail;
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = (int)((wxDateSpan const *)arg1)->GetYears();
25705
25706 wxPyEndAllowThreads(__tstate);
25707 if (PyErr_Occurred()) SWIG_fail;
25708 }
25709 {
25710 resultobj = SWIG_From_int((int)(result));
25711 }
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25719 PyObject *resultobj;
25720 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25721 int result;
25722 PyObject * obj0 = 0 ;
25723 char *kwnames[] = {
25724 (char *) "self", NULL
25725 };
25726
25727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25729 if (SWIG_arg_fail(1)) SWIG_fail;
25730 {
25731 PyThreadState* __tstate = wxPyBeginAllowThreads();
25732 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25733
25734 wxPyEndAllowThreads(__tstate);
25735 if (PyErr_Occurred()) SWIG_fail;
25736 }
25737 {
25738 resultobj = SWIG_From_int((int)(result));
25739 }
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj;
25748 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25749 int result;
25750 PyObject * obj0 = 0 ;
25751 char *kwnames[] = {
25752 (char *) "self", NULL
25753 };
25754
25755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25757 if (SWIG_arg_fail(1)) SWIG_fail;
25758 {
25759 PyThreadState* __tstate = wxPyBeginAllowThreads();
25760 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25761
25762 wxPyEndAllowThreads(__tstate);
25763 if (PyErr_Occurred()) SWIG_fail;
25764 }
25765 {
25766 resultobj = SWIG_From_int((int)(result));
25767 }
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj;
25776 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25777 int result;
25778 PyObject * obj0 = 0 ;
25779 char *kwnames[] = {
25780 (char *) "self", NULL
25781 };
25782
25783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25785 if (SWIG_arg_fail(1)) SWIG_fail;
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = (int)((wxDateSpan const *)arg1)->GetDays();
25789
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 {
25794 resultobj = SWIG_From_int((int)(result));
25795 }
25796 return resultobj;
25797 fail:
25798 return NULL;
25799 }
25800
25801
25802 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25803 PyObject *resultobj;
25804 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25805 int result;
25806 PyObject * obj0 = 0 ;
25807 char *kwnames[] = {
25808 (char *) "self", NULL
25809 };
25810
25811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25813 if (SWIG_arg_fail(1)) SWIG_fail;
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25817
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 {
25822 resultobj = SWIG_From_int((int)(result));
25823 }
25824 return resultobj;
25825 fail:
25826 return NULL;
25827 }
25828
25829
25830 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25831 PyObject *resultobj;
25832 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25833 wxDateSpan *arg2 = 0 ;
25834 wxDateSpan *result;
25835 PyObject * obj0 = 0 ;
25836 PyObject * obj1 = 0 ;
25837 char *kwnames[] = {
25838 (char *) "self",(char *) "other", NULL
25839 };
25840
25841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25843 if (SWIG_arg_fail(1)) SWIG_fail;
25844 {
25845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25846 if (SWIG_arg_fail(2)) SWIG_fail;
25847 if (arg2 == NULL) {
25848 SWIG_null_ref("wxDateSpan");
25849 }
25850 if (SWIG_arg_fail(2)) SWIG_fail;
25851 }
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 {
25855 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25856 result = (wxDateSpan *) &_result_ref;
25857 }
25858
25859 wxPyEndAllowThreads(__tstate);
25860 if (PyErr_Occurred()) SWIG_fail;
25861 }
25862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25870 PyObject *resultobj;
25871 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25872 wxDateSpan *arg2 = 0 ;
25873 wxDateSpan *result;
25874 PyObject * obj0 = 0 ;
25875 PyObject * obj1 = 0 ;
25876 char *kwnames[] = {
25877 (char *) "self",(char *) "other", NULL
25878 };
25879
25880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25882 if (SWIG_arg_fail(1)) SWIG_fail;
25883 {
25884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25885 if (SWIG_arg_fail(2)) SWIG_fail;
25886 if (arg2 == NULL) {
25887 SWIG_null_ref("wxDateSpan");
25888 }
25889 if (SWIG_arg_fail(2)) SWIG_fail;
25890 }
25891 {
25892 PyThreadState* __tstate = wxPyBeginAllowThreads();
25893 {
25894 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25895 result = (wxDateSpan *) &_result_ref;
25896 }
25897
25898 wxPyEndAllowThreads(__tstate);
25899 if (PyErr_Occurred()) SWIG_fail;
25900 }
25901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25902 return resultobj;
25903 fail:
25904 return NULL;
25905 }
25906
25907
25908 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25909 PyObject *resultobj;
25910 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25911 wxDateSpan *result;
25912 PyObject * obj0 = 0 ;
25913 char *kwnames[] = {
25914 (char *) "self", NULL
25915 };
25916
25917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25919 if (SWIG_arg_fail(1)) SWIG_fail;
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 {
25923 wxDateSpan &_result_ref = (arg1)->Neg();
25924 result = (wxDateSpan *) &_result_ref;
25925 }
25926
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25938 PyObject *resultobj;
25939 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25940 int arg2 ;
25941 wxDateSpan *result;
25942 PyObject * obj0 = 0 ;
25943 PyObject * obj1 = 0 ;
25944 char *kwnames[] = {
25945 (char *) "self",(char *) "factor", NULL
25946 };
25947
25948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25950 if (SWIG_arg_fail(1)) SWIG_fail;
25951 {
25952 arg2 = (int)(SWIG_As_int(obj1));
25953 if (SWIG_arg_fail(2)) SWIG_fail;
25954 }
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 {
25958 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25959 result = (wxDateSpan *) &_result_ref;
25960 }
25961
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj;
25974 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25975 wxDateSpan *arg2 = 0 ;
25976 wxDateSpan *result;
25977 PyObject * obj0 = 0 ;
25978 PyObject * obj1 = 0 ;
25979 char *kwnames[] = {
25980 (char *) "self",(char *) "other", NULL
25981 };
25982
25983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25985 if (SWIG_arg_fail(1)) SWIG_fail;
25986 {
25987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25988 if (SWIG_arg_fail(2)) SWIG_fail;
25989 if (arg2 == NULL) {
25990 SWIG_null_ref("wxDateSpan");
25991 }
25992 if (SWIG_arg_fail(2)) SWIG_fail;
25993 }
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 {
25997 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25998 result = (wxDateSpan *) &_result_ref;
25999 }
26000
26001 wxPyEndAllowThreads(__tstate);
26002 if (PyErr_Occurred()) SWIG_fail;
26003 }
26004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26005 return resultobj;
26006 fail:
26007 return NULL;
26008 }
26009
26010
26011 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26012 PyObject *resultobj;
26013 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26014 wxDateSpan *arg2 = 0 ;
26015 wxDateSpan *result;
26016 PyObject * obj0 = 0 ;
26017 PyObject * obj1 = 0 ;
26018 char *kwnames[] = {
26019 (char *) "self",(char *) "other", NULL
26020 };
26021
26022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26024 if (SWIG_arg_fail(1)) SWIG_fail;
26025 {
26026 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26027 if (SWIG_arg_fail(2)) SWIG_fail;
26028 if (arg2 == NULL) {
26029 SWIG_null_ref("wxDateSpan");
26030 }
26031 if (SWIG_arg_fail(2)) SWIG_fail;
26032 }
26033 {
26034 PyThreadState* __tstate = wxPyBeginAllowThreads();
26035 {
26036 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26037 result = (wxDateSpan *) &_result_ref;
26038 }
26039
26040 wxPyEndAllowThreads(__tstate);
26041 if (PyErr_Occurred()) SWIG_fail;
26042 }
26043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26044 return resultobj;
26045 fail:
26046 return NULL;
26047 }
26048
26049
26050 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26051 PyObject *resultobj;
26052 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26053 wxDateSpan *result;
26054 PyObject * obj0 = 0 ;
26055 char *kwnames[] = {
26056 (char *) "self", NULL
26057 };
26058
26059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26061 if (SWIG_arg_fail(1)) SWIG_fail;
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 {
26065 wxDateSpan &_result_ref = (arg1)->operator -();
26066 result = (wxDateSpan *) &_result_ref;
26067 }
26068
26069 wxPyEndAllowThreads(__tstate);
26070 if (PyErr_Occurred()) SWIG_fail;
26071 }
26072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26073 return resultobj;
26074 fail:
26075 return NULL;
26076 }
26077
26078
26079 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26080 PyObject *resultobj;
26081 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26082 int arg2 ;
26083 wxDateSpan *result;
26084 PyObject * obj0 = 0 ;
26085 PyObject * obj1 = 0 ;
26086 char *kwnames[] = {
26087 (char *) "self",(char *) "factor", NULL
26088 };
26089
26090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26092 if (SWIG_arg_fail(1)) SWIG_fail;
26093 {
26094 arg2 = (int)(SWIG_As_int(obj1));
26095 if (SWIG_arg_fail(2)) SWIG_fail;
26096 }
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 {
26100 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26101 result = (wxDateSpan *) &_result_ref;
26102 }
26103
26104 wxPyEndAllowThreads(__tstate);
26105 if (PyErr_Occurred()) SWIG_fail;
26106 }
26107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26108 return resultobj;
26109 fail:
26110 return NULL;
26111 }
26112
26113
26114 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26115 PyObject *resultobj;
26116 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26117 wxDateSpan *arg2 = 0 ;
26118 wxDateSpan result;
26119 PyObject * obj0 = 0 ;
26120 PyObject * obj1 = 0 ;
26121 char *kwnames[] = {
26122 (char *) "self",(char *) "other", NULL
26123 };
26124
26125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26127 if (SWIG_arg_fail(1)) SWIG_fail;
26128 {
26129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26130 if (SWIG_arg_fail(2)) SWIG_fail;
26131 if (arg2 == NULL) {
26132 SWIG_null_ref("wxDateSpan");
26133 }
26134 if (SWIG_arg_fail(2)) SWIG_fail;
26135 }
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26139
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 {
26144 wxDateSpan * resultptr;
26145 resultptr = new wxDateSpan((wxDateSpan &)(result));
26146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26147 }
26148 return resultobj;
26149 fail:
26150 return NULL;
26151 }
26152
26153
26154 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26155 PyObject *resultobj;
26156 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26157 wxDateSpan *arg2 = 0 ;
26158 wxDateSpan result;
26159 PyObject * obj0 = 0 ;
26160 PyObject * obj1 = 0 ;
26161 char *kwnames[] = {
26162 (char *) "self",(char *) "other", NULL
26163 };
26164
26165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26167 if (SWIG_arg_fail(1)) SWIG_fail;
26168 {
26169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26170 if (SWIG_arg_fail(2)) SWIG_fail;
26171 if (arg2 == NULL) {
26172 SWIG_null_ref("wxDateSpan");
26173 }
26174 if (SWIG_arg_fail(2)) SWIG_fail;
26175 }
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26179
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 {
26184 wxDateSpan * resultptr;
26185 resultptr = new wxDateSpan((wxDateSpan &)(result));
26186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26187 }
26188 return resultobj;
26189 fail:
26190 return NULL;
26191 }
26192
26193
26194 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26195 PyObject *resultobj;
26196 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26197 int arg2 ;
26198 wxDateSpan result;
26199 PyObject * obj0 = 0 ;
26200 PyObject * obj1 = 0 ;
26201 char *kwnames[] = {
26202 (char *) "self",(char *) "n", NULL
26203 };
26204
26205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26207 if (SWIG_arg_fail(1)) SWIG_fail;
26208 {
26209 arg2 = (int)(SWIG_As_int(obj1));
26210 if (SWIG_arg_fail(2)) SWIG_fail;
26211 }
26212 {
26213 PyThreadState* __tstate = wxPyBeginAllowThreads();
26214 result = wxDateSpan___mul__(arg1,arg2);
26215
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 {
26220 wxDateSpan * resultptr;
26221 resultptr = new wxDateSpan((wxDateSpan &)(result));
26222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26223 }
26224 return resultobj;
26225 fail:
26226 return NULL;
26227 }
26228
26229
26230 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26231 PyObject *resultobj;
26232 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26233 int arg2 ;
26234 wxDateSpan result;
26235 PyObject * obj0 = 0 ;
26236 PyObject * obj1 = 0 ;
26237 char *kwnames[] = {
26238 (char *) "self",(char *) "n", NULL
26239 };
26240
26241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26243 if (SWIG_arg_fail(1)) SWIG_fail;
26244 {
26245 arg2 = (int)(SWIG_As_int(obj1));
26246 if (SWIG_arg_fail(2)) SWIG_fail;
26247 }
26248 {
26249 PyThreadState* __tstate = wxPyBeginAllowThreads();
26250 result = wxDateSpan___rmul__(arg1,arg2);
26251
26252 wxPyEndAllowThreads(__tstate);
26253 if (PyErr_Occurred()) SWIG_fail;
26254 }
26255 {
26256 wxDateSpan * resultptr;
26257 resultptr = new wxDateSpan((wxDateSpan &)(result));
26258 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26259 }
26260 return resultobj;
26261 fail:
26262 return NULL;
26263 }
26264
26265
26266 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26267 PyObject *resultobj;
26268 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26269 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26270 bool result;
26271 PyObject * obj0 = 0 ;
26272 PyObject * obj1 = 0 ;
26273 char *kwnames[] = {
26274 (char *) "self",(char *) "other", NULL
26275 };
26276
26277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26279 if (SWIG_arg_fail(1)) SWIG_fail;
26280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26281 if (SWIG_arg_fail(2)) SWIG_fail;
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 {
26290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26291 }
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26299 PyObject *resultobj;
26300 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26301 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26302 bool result;
26303 PyObject * obj0 = 0 ;
26304 PyObject * obj1 = 0 ;
26305 char *kwnames[] = {
26306 (char *) "self",(char *) "other", NULL
26307 };
26308
26309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26311 if (SWIG_arg_fail(1)) SWIG_fail;
26312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26313 if (SWIG_arg_fail(2)) SWIG_fail;
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26317
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 {
26322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26323 }
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26331 PyObject *obj;
26332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26333 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26334 Py_INCREF(obj);
26335 return Py_BuildValue((char *)"");
26336 }
26337 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj;
26339 long result;
26340 char *kwnames[] = {
26341 NULL
26342 };
26343
26344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26345 {
26346 PyThreadState* __tstate = wxPyBeginAllowThreads();
26347 result = (long)wxGetLocalTime();
26348
26349 wxPyEndAllowThreads(__tstate);
26350 if (PyErr_Occurred()) SWIG_fail;
26351 }
26352 {
26353 resultobj = SWIG_From_long((long)(result));
26354 }
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26362 PyObject *resultobj;
26363 long result;
26364 char *kwnames[] = {
26365 NULL
26366 };
26367
26368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 result = (long)wxGetUTCTime();
26372
26373 wxPyEndAllowThreads(__tstate);
26374 if (PyErr_Occurred()) SWIG_fail;
26375 }
26376 {
26377 resultobj = SWIG_From_long((long)(result));
26378 }
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26386 PyObject *resultobj;
26387 long result;
26388 char *kwnames[] = {
26389 NULL
26390 };
26391
26392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (long)wxGetCurrentTime();
26396
26397 wxPyEndAllowThreads(__tstate);
26398 if (PyErr_Occurred()) SWIG_fail;
26399 }
26400 {
26401 resultobj = SWIG_From_long((long)(result));
26402 }
26403 return resultobj;
26404 fail:
26405 return NULL;
26406 }
26407
26408
26409 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26410 PyObject *resultobj;
26411 wxLongLong result;
26412 char *kwnames[] = {
26413 NULL
26414 };
26415
26416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26417 {
26418 PyThreadState* __tstate = wxPyBeginAllowThreads();
26419 result = wxGetLocalTimeMillis();
26420
26421 wxPyEndAllowThreads(__tstate);
26422 if (PyErr_Occurred()) SWIG_fail;
26423 }
26424 {
26425 PyObject *hi, *lo, *shifter, *shifted;
26426 hi = PyLong_FromLong( (&result)->GetHi() );
26427 lo = PyLong_FromLong( (&result)->GetLo() );
26428 shifter = PyLong_FromLong(32);
26429 shifted = PyNumber_Lshift(hi, shifter);
26430 resultobj = PyNumber_Or(shifted, lo);
26431 Py_DECREF(hi);
26432 Py_DECREF(lo);
26433 Py_DECREF(shifter);
26434 Py_DECREF(shifted);
26435 }
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 static int _wrap_DefaultDateTime_set(PyObject *) {
26443 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26444 return 1;
26445 }
26446
26447
26448 static PyObject *_wrap_DefaultDateTime_get(void) {
26449 PyObject *pyobj;
26450
26451 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26452 return pyobj;
26453 }
26454
26455
26456 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26457 PyObject *resultobj;
26458 wxDataFormatId arg1 ;
26459 wxDataFormat *result;
26460 PyObject * obj0 = 0 ;
26461 char *kwnames[] = {
26462 (char *) "type", NULL
26463 };
26464
26465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26466 {
26467 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26468 if (SWIG_arg_fail(1)) SWIG_fail;
26469 }
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26473
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj;
26486 wxString *arg1 = 0 ;
26487 wxDataFormat *result;
26488 bool temp1 = false ;
26489 PyObject * obj0 = 0 ;
26490 char *kwnames[] = {
26491 (char *) "format", NULL
26492 };
26493
26494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26495 {
26496 arg1 = wxString_in_helper(obj0);
26497 if (arg1 == NULL) SWIG_fail;
26498 temp1 = true;
26499 }
26500 {
26501 PyThreadState* __tstate = wxPyBeginAllowThreads();
26502 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26503
26504 wxPyEndAllowThreads(__tstate);
26505 if (PyErr_Occurred()) SWIG_fail;
26506 }
26507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26508 {
26509 if (temp1)
26510 delete arg1;
26511 }
26512 return resultobj;
26513 fail:
26514 {
26515 if (temp1)
26516 delete arg1;
26517 }
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26525 PyObject * obj0 = 0 ;
26526 char *kwnames[] = {
26527 (char *) "self", NULL
26528 };
26529
26530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26532 if (SWIG_arg_fail(1)) SWIG_fail;
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 delete arg1;
26536
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 Py_INCREF(Py_None); resultobj = Py_None;
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26548 PyObject *resultobj;
26549 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26550 wxDataFormatId arg2 ;
26551 bool result;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554
26555 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26557 if (SWIG_arg_fail(1)) SWIG_fail;
26558 {
26559 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26560 if (SWIG_arg_fail(2)) SWIG_fail;
26561 }
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26565
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 {
26570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26571 }
26572 return resultobj;
26573 fail:
26574 return NULL;
26575 }
26576
26577
26578 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26579 PyObject *resultobj;
26580 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26581 wxDataFormatId arg2 ;
26582 bool result;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585
26586 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26588 if (SWIG_arg_fail(1)) SWIG_fail;
26589 {
26590 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26591 if (SWIG_arg_fail(2)) SWIG_fail;
26592 }
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 {
26601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26602 }
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26610 PyObject *resultobj;
26611 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26612 wxDataFormat *arg2 = 0 ;
26613 bool result;
26614 PyObject * obj0 = 0 ;
26615 PyObject * obj1 = 0 ;
26616
26617 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26619 if (SWIG_arg_fail(1)) SWIG_fail;
26620 {
26621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26622 if (SWIG_arg_fail(2)) SWIG_fail;
26623 if (arg2 == NULL) {
26624 SWIG_null_ref("wxDataFormat");
26625 }
26626 if (SWIG_arg_fail(2)) SWIG_fail;
26627 }
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26631
26632 wxPyEndAllowThreads(__tstate);
26633 if (PyErr_Occurred()) SWIG_fail;
26634 }
26635 {
26636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26637 }
26638 return resultobj;
26639 fail:
26640 return NULL;
26641 }
26642
26643
26644 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26645 int argc;
26646 PyObject *argv[3];
26647 int ii;
26648
26649 argc = PyObject_Length(args);
26650 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26651 argv[ii] = PyTuple_GetItem(args,ii);
26652 }
26653 if (argc == 2) {
26654 int _v;
26655 {
26656 void *ptr;
26657 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26658 _v = 0;
26659 PyErr_Clear();
26660 } else {
26661 _v = 1;
26662 }
26663 }
26664 if (_v) {
26665 {
26666 void *ptr = 0;
26667 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26668 _v = 0;
26669 PyErr_Clear();
26670 } else {
26671 _v = (ptr != 0);
26672 }
26673 }
26674 if (_v) {
26675 return _wrap_DataFormat___eq____SWIG_1(self,args);
26676 }
26677 }
26678 }
26679 if (argc == 2) {
26680 int _v;
26681 {
26682 void *ptr;
26683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26684 _v = 0;
26685 PyErr_Clear();
26686 } else {
26687 _v = 1;
26688 }
26689 }
26690 if (_v) {
26691 _v = SWIG_Check_int(argv[1]);
26692 if (_v) {
26693 return _wrap_DataFormat___eq____SWIG_0(self,args);
26694 }
26695 }
26696 }
26697
26698 Py_INCREF(Py_NotImplemented);
26699 return Py_NotImplemented;
26700 }
26701
26702
26703 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26704 PyObject *resultobj;
26705 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26706 wxDataFormat *arg2 = 0 ;
26707 bool result;
26708 PyObject * obj0 = 0 ;
26709 PyObject * obj1 = 0 ;
26710
26711 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26713 if (SWIG_arg_fail(1)) SWIG_fail;
26714 {
26715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26716 if (SWIG_arg_fail(2)) SWIG_fail;
26717 if (arg2 == NULL) {
26718 SWIG_null_ref("wxDataFormat");
26719 }
26720 if (SWIG_arg_fail(2)) SWIG_fail;
26721 }
26722 {
26723 PyThreadState* __tstate = wxPyBeginAllowThreads();
26724 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26725
26726 wxPyEndAllowThreads(__tstate);
26727 if (PyErr_Occurred()) SWIG_fail;
26728 }
26729 {
26730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26731 }
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26739 int argc;
26740 PyObject *argv[3];
26741 int ii;
26742
26743 argc = PyObject_Length(args);
26744 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26745 argv[ii] = PyTuple_GetItem(args,ii);
26746 }
26747 if (argc == 2) {
26748 int _v;
26749 {
26750 void *ptr;
26751 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26752 _v = 0;
26753 PyErr_Clear();
26754 } else {
26755 _v = 1;
26756 }
26757 }
26758 if (_v) {
26759 {
26760 void *ptr = 0;
26761 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26762 _v = 0;
26763 PyErr_Clear();
26764 } else {
26765 _v = (ptr != 0);
26766 }
26767 }
26768 if (_v) {
26769 return _wrap_DataFormat___ne____SWIG_1(self,args);
26770 }
26771 }
26772 }
26773 if (argc == 2) {
26774 int _v;
26775 {
26776 void *ptr;
26777 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26778 _v = 0;
26779 PyErr_Clear();
26780 } else {
26781 _v = 1;
26782 }
26783 }
26784 if (_v) {
26785 _v = SWIG_Check_int(argv[1]);
26786 if (_v) {
26787 return _wrap_DataFormat___ne____SWIG_0(self,args);
26788 }
26789 }
26790 }
26791
26792 Py_INCREF(Py_NotImplemented);
26793 return Py_NotImplemented;
26794 }
26795
26796
26797 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26798 PyObject *resultobj;
26799 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26800 wxDataFormatId arg2 ;
26801 PyObject * obj0 = 0 ;
26802 PyObject * obj1 = 0 ;
26803 char *kwnames[] = {
26804 (char *) "self",(char *) "format", NULL
26805 };
26806
26807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26809 if (SWIG_arg_fail(1)) SWIG_fail;
26810 {
26811 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26812 if (SWIG_arg_fail(2)) SWIG_fail;
26813 }
26814 {
26815 PyThreadState* __tstate = wxPyBeginAllowThreads();
26816 (arg1)->SetType((wxDataFormatId )arg2);
26817
26818 wxPyEndAllowThreads(__tstate);
26819 if (PyErr_Occurred()) SWIG_fail;
26820 }
26821 Py_INCREF(Py_None); resultobj = Py_None;
26822 return resultobj;
26823 fail:
26824 return NULL;
26825 }
26826
26827
26828 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26829 PyObject *resultobj;
26830 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26831 wxDataFormatId result;
26832 PyObject * obj0 = 0 ;
26833 char *kwnames[] = {
26834 (char *) "self", NULL
26835 };
26836
26837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26839 if (SWIG_arg_fail(1)) SWIG_fail;
26840 {
26841 PyThreadState* __tstate = wxPyBeginAllowThreads();
26842 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26843
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 resultobj = SWIG_From_int((result));
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj;
26856 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26857 wxString result;
26858 PyObject * obj0 = 0 ;
26859 char *kwnames[] = {
26860 (char *) "self", NULL
26861 };
26862
26863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26865 if (SWIG_arg_fail(1)) SWIG_fail;
26866 {
26867 PyThreadState* __tstate = wxPyBeginAllowThreads();
26868 result = ((wxDataFormat const *)arg1)->GetId();
26869
26870 wxPyEndAllowThreads(__tstate);
26871 if (PyErr_Occurred()) SWIG_fail;
26872 }
26873 {
26874 #if wxUSE_UNICODE
26875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26876 #else
26877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26878 #endif
26879 }
26880 return resultobj;
26881 fail:
26882 return NULL;
26883 }
26884
26885
26886 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26887 PyObject *resultobj;
26888 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26889 wxString *arg2 = 0 ;
26890 bool temp2 = false ;
26891 PyObject * obj0 = 0 ;
26892 PyObject * obj1 = 0 ;
26893 char *kwnames[] = {
26894 (char *) "self",(char *) "format", NULL
26895 };
26896
26897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26899 if (SWIG_arg_fail(1)) SWIG_fail;
26900 {
26901 arg2 = wxString_in_helper(obj1);
26902 if (arg2 == NULL) SWIG_fail;
26903 temp2 = true;
26904 }
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 (arg1)->SetId((wxString const &)*arg2);
26908
26909 wxPyEndAllowThreads(__tstate);
26910 if (PyErr_Occurred()) SWIG_fail;
26911 }
26912 Py_INCREF(Py_None); resultobj = Py_None;
26913 {
26914 if (temp2)
26915 delete arg2;
26916 }
26917 return resultobj;
26918 fail:
26919 {
26920 if (temp2)
26921 delete arg2;
26922 }
26923 return NULL;
26924 }
26925
26926
26927 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26928 PyObject *obj;
26929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26930 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26931 Py_INCREF(obj);
26932 return Py_BuildValue((char *)"");
26933 }
26934 static int _wrap_FormatInvalid_set(PyObject *) {
26935 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26936 return 1;
26937 }
26938
26939
26940 static PyObject *_wrap_FormatInvalid_get(void) {
26941 PyObject *pyobj;
26942
26943 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26944 return pyobj;
26945 }
26946
26947
26948 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj;
26950 wxDataObject *arg1 = (wxDataObject *) 0 ;
26951 PyObject * obj0 = 0 ;
26952 char *kwnames[] = {
26953 (char *) "self", NULL
26954 };
26955
26956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26958 if (SWIG_arg_fail(1)) SWIG_fail;
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 delete arg1;
26962
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 Py_INCREF(Py_None); resultobj = Py_None;
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj;
26975 wxDataObject *arg1 = (wxDataObject *) 0 ;
26976 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26977 SwigValueWrapper<wxDataFormat > result;
26978 PyObject * obj0 = 0 ;
26979 PyObject * obj1 = 0 ;
26980 char *kwnames[] = {
26981 (char *) "self",(char *) "dir", NULL
26982 };
26983
26984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26986 if (SWIG_arg_fail(1)) SWIG_fail;
26987 if (obj1) {
26988 {
26989 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26990 if (SWIG_arg_fail(2)) SWIG_fail;
26991 }
26992 }
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26996
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 {
27001 wxDataFormat * resultptr;
27002 resultptr = new wxDataFormat((wxDataFormat &)(result));
27003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27004 }
27005 return resultobj;
27006 fail:
27007 return NULL;
27008 }
27009
27010
27011 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27012 PyObject *resultobj;
27013 wxDataObject *arg1 = (wxDataObject *) 0 ;
27014 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27015 size_t result;
27016 PyObject * obj0 = 0 ;
27017 PyObject * obj1 = 0 ;
27018 char *kwnames[] = {
27019 (char *) "self",(char *) "dir", NULL
27020 };
27021
27022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27024 if (SWIG_arg_fail(1)) SWIG_fail;
27025 if (obj1) {
27026 {
27027 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27028 if (SWIG_arg_fail(2)) SWIG_fail;
27029 }
27030 }
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27034
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 {
27039 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27040 }
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj;
27049 wxDataObject *arg1 = (wxDataObject *) 0 ;
27050 wxDataFormat *arg2 = 0 ;
27051 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27052 bool result;
27053 PyObject * obj0 = 0 ;
27054 PyObject * obj1 = 0 ;
27055 PyObject * obj2 = 0 ;
27056 char *kwnames[] = {
27057 (char *) "self",(char *) "format",(char *) "dir", NULL
27058 };
27059
27060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27062 if (SWIG_arg_fail(1)) SWIG_fail;
27063 {
27064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27065 if (SWIG_arg_fail(2)) SWIG_fail;
27066 if (arg2 == NULL) {
27067 SWIG_null_ref("wxDataFormat");
27068 }
27069 if (SWIG_arg_fail(2)) SWIG_fail;
27070 }
27071 if (obj2) {
27072 {
27073 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27074 if (SWIG_arg_fail(3)) SWIG_fail;
27075 }
27076 }
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27080
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 {
27085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27086 }
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj;
27095 wxDataObject *arg1 = (wxDataObject *) 0 ;
27096 wxDataFormat *arg2 = 0 ;
27097 size_t result;
27098 PyObject * obj0 = 0 ;
27099 PyObject * obj1 = 0 ;
27100 char *kwnames[] = {
27101 (char *) "self",(char *) "format", NULL
27102 };
27103
27104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27106 if (SWIG_arg_fail(1)) SWIG_fail;
27107 {
27108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27109 if (SWIG_arg_fail(2)) SWIG_fail;
27110 if (arg2 == NULL) {
27111 SWIG_null_ref("wxDataFormat");
27112 }
27113 if (SWIG_arg_fail(2)) SWIG_fail;
27114 }
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27118
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 {
27123 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27124 }
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj;
27133 wxDataObject *arg1 = (wxDataObject *) 0 ;
27134 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27135 PyObject *result;
27136 PyObject * obj0 = 0 ;
27137 PyObject * obj1 = 0 ;
27138 char *kwnames[] = {
27139 (char *) "self",(char *) "dir", NULL
27140 };
27141
27142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27144 if (SWIG_arg_fail(1)) SWIG_fail;
27145 if (obj1) {
27146 {
27147 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27148 if (SWIG_arg_fail(2)) SWIG_fail;
27149 }
27150 }
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27154
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 resultobj = result;
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27166 PyObject *resultobj;
27167 wxDataObject *arg1 = (wxDataObject *) 0 ;
27168 wxDataFormat *arg2 = 0 ;
27169 PyObject *result;
27170 PyObject * obj0 = 0 ;
27171 PyObject * obj1 = 0 ;
27172 char *kwnames[] = {
27173 (char *) "self",(char *) "format", NULL
27174 };
27175
27176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27178 if (SWIG_arg_fail(1)) SWIG_fail;
27179 {
27180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27181 if (SWIG_arg_fail(2)) SWIG_fail;
27182 if (arg2 == NULL) {
27183 SWIG_null_ref("wxDataFormat");
27184 }
27185 if (SWIG_arg_fail(2)) SWIG_fail;
27186 }
27187 {
27188 PyThreadState* __tstate = wxPyBeginAllowThreads();
27189 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27190
27191 wxPyEndAllowThreads(__tstate);
27192 if (PyErr_Occurred()) SWIG_fail;
27193 }
27194 resultobj = result;
27195 return resultobj;
27196 fail:
27197 return NULL;
27198 }
27199
27200
27201 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27202 PyObject *resultobj;
27203 wxDataObject *arg1 = (wxDataObject *) 0 ;
27204 wxDataFormat *arg2 = 0 ;
27205 PyObject *arg3 = (PyObject *) 0 ;
27206 bool result;
27207 PyObject * obj0 = 0 ;
27208 PyObject * obj1 = 0 ;
27209 PyObject * obj2 = 0 ;
27210 char *kwnames[] = {
27211 (char *) "self",(char *) "format",(char *) "data", NULL
27212 };
27213
27214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27216 if (SWIG_arg_fail(1)) SWIG_fail;
27217 {
27218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(2)) SWIG_fail;
27220 if (arg2 == NULL) {
27221 SWIG_null_ref("wxDataFormat");
27222 }
27223 if (SWIG_arg_fail(2)) SWIG_fail;
27224 }
27225 arg3 = obj2;
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27229
27230 wxPyEndAllowThreads(__tstate);
27231 if (PyErr_Occurred()) SWIG_fail;
27232 }
27233 {
27234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27235 }
27236 return resultobj;
27237 fail:
27238 return NULL;
27239 }
27240
27241
27242 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27243 PyObject *obj;
27244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27245 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27246 Py_INCREF(obj);
27247 return Py_BuildValue((char *)"");
27248 }
27249 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27250 PyObject *resultobj;
27251 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27252 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27253 wxDataObjectSimple *result;
27254 PyObject * obj0 = 0 ;
27255 char *kwnames[] = {
27256 (char *) "format", NULL
27257 };
27258
27259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27260 if (obj0) {
27261 {
27262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27263 if (SWIG_arg_fail(1)) SWIG_fail;
27264 if (arg1 == NULL) {
27265 SWIG_null_ref("wxDataFormat");
27266 }
27267 if (SWIG_arg_fail(1)) SWIG_fail;
27268 }
27269 }
27270 {
27271 PyThreadState* __tstate = wxPyBeginAllowThreads();
27272 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27273
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27285 PyObject *resultobj;
27286 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27287 wxDataFormat *result;
27288 PyObject * obj0 = 0 ;
27289 char *kwnames[] = {
27290 (char *) "self", NULL
27291 };
27292
27293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27295 if (SWIG_arg_fail(1)) SWIG_fail;
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 {
27299 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27300 result = (wxDataFormat *) &_result_ref;
27301 }
27302
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27307 return resultobj;
27308 fail:
27309 return NULL;
27310 }
27311
27312
27313 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27314 PyObject *resultobj;
27315 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27316 wxDataFormat *arg2 = 0 ;
27317 PyObject * obj0 = 0 ;
27318 PyObject * obj1 = 0 ;
27319 char *kwnames[] = {
27320 (char *) "self",(char *) "format", NULL
27321 };
27322
27323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27325 if (SWIG_arg_fail(1)) SWIG_fail;
27326 {
27327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27328 if (SWIG_arg_fail(2)) SWIG_fail;
27329 if (arg2 == NULL) {
27330 SWIG_null_ref("wxDataFormat");
27331 }
27332 if (SWIG_arg_fail(2)) SWIG_fail;
27333 }
27334 {
27335 PyThreadState* __tstate = wxPyBeginAllowThreads();
27336 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27337
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 Py_INCREF(Py_None); resultobj = Py_None;
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27349 PyObject *resultobj;
27350 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27351 size_t result;
27352 PyObject * obj0 = 0 ;
27353 char *kwnames[] = {
27354 (char *) "self", NULL
27355 };
27356
27357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27359 if (SWIG_arg_fail(1)) SWIG_fail;
27360 {
27361 PyThreadState* __tstate = wxPyBeginAllowThreads();
27362 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27363
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 {
27368 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27369 }
27370 return resultobj;
27371 fail:
27372 return NULL;
27373 }
27374
27375
27376 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27377 PyObject *resultobj;
27378 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27379 PyObject *result;
27380 PyObject * obj0 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 {
27389 PyThreadState* __tstate = wxPyBeginAllowThreads();
27390 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27391
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 resultobj = result;
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27403 PyObject *resultobj;
27404 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27405 PyObject *arg2 = (PyObject *) 0 ;
27406 bool result;
27407 PyObject * obj0 = 0 ;
27408 PyObject * obj1 = 0 ;
27409 char *kwnames[] = {
27410 (char *) "self",(char *) "data", NULL
27411 };
27412
27413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27415 if (SWIG_arg_fail(1)) SWIG_fail;
27416 arg2 = obj1;
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27420
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 {
27425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27426 }
27427 return resultobj;
27428 fail:
27429 return NULL;
27430 }
27431
27432
27433 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27434 PyObject *obj;
27435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27436 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27437 Py_INCREF(obj);
27438 return Py_BuildValue((char *)"");
27439 }
27440 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27441 PyObject *resultobj;
27442 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27443 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27444 wxPyDataObjectSimple *result;
27445 PyObject * obj0 = 0 ;
27446 char *kwnames[] = {
27447 (char *) "format", NULL
27448 };
27449
27450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27451 if (obj0) {
27452 {
27453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27454 if (SWIG_arg_fail(1)) SWIG_fail;
27455 if (arg1 == NULL) {
27456 SWIG_null_ref("wxDataFormat");
27457 }
27458 if (SWIG_arg_fail(1)) SWIG_fail;
27459 }
27460 }
27461 {
27462 PyThreadState* __tstate = wxPyBeginAllowThreads();
27463 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27464
27465 wxPyEndAllowThreads(__tstate);
27466 if (PyErr_Occurred()) SWIG_fail;
27467 }
27468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27469 return resultobj;
27470 fail:
27471 return NULL;
27472 }
27473
27474
27475 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27476 PyObject *resultobj;
27477 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27478 PyObject *arg2 = (PyObject *) 0 ;
27479 PyObject *arg3 = (PyObject *) 0 ;
27480 PyObject * obj0 = 0 ;
27481 PyObject * obj1 = 0 ;
27482 PyObject * obj2 = 0 ;
27483 char *kwnames[] = {
27484 (char *) "self",(char *) "self",(char *) "_class", NULL
27485 };
27486
27487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27489 if (SWIG_arg_fail(1)) SWIG_fail;
27490 arg2 = obj1;
27491 arg3 = obj2;
27492 {
27493 PyThreadState* __tstate = wxPyBeginAllowThreads();
27494 (arg1)->_setCallbackInfo(arg2,arg3);
27495
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 Py_INCREF(Py_None); resultobj = Py_None;
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27507 PyObject *obj;
27508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27509 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27510 Py_INCREF(obj);
27511 return Py_BuildValue((char *)"");
27512 }
27513 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27514 PyObject *resultobj;
27515 wxDataObjectComposite *result;
27516 char *kwnames[] = {
27517 NULL
27518 };
27519
27520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27524
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj;
27537 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27538 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27539 bool arg3 = (bool) false ;
27540 PyObject * obj0 = 0 ;
27541 PyObject * obj1 = 0 ;
27542 PyObject * obj2 = 0 ;
27543 char *kwnames[] = {
27544 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27545 };
27546
27547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27549 if (SWIG_arg_fail(1)) SWIG_fail;
27550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27551 if (SWIG_arg_fail(2)) SWIG_fail;
27552 if (obj2) {
27553 {
27554 arg3 = (bool)(SWIG_As_bool(obj2));
27555 if (SWIG_arg_fail(3)) SWIG_fail;
27556 }
27557 }
27558 {
27559 PyThreadState* __tstate = wxPyBeginAllowThreads();
27560 (arg1)->Add(arg2,arg3);
27561
27562 wxPyEndAllowThreads(__tstate);
27563 if (PyErr_Occurred()) SWIG_fail;
27564 }
27565 Py_INCREF(Py_None); resultobj = Py_None;
27566 return resultobj;
27567 fail:
27568 return NULL;
27569 }
27570
27571
27572 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27573 PyObject *obj;
27574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27575 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27576 Py_INCREF(obj);
27577 return Py_BuildValue((char *)"");
27578 }
27579 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27580 PyObject *resultobj;
27581 wxString const &arg1_defvalue = wxPyEmptyString ;
27582 wxString *arg1 = (wxString *) &arg1_defvalue ;
27583 wxTextDataObject *result;
27584 bool temp1 = false ;
27585 PyObject * obj0 = 0 ;
27586 char *kwnames[] = {
27587 (char *) "text", NULL
27588 };
27589
27590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27591 if (obj0) {
27592 {
27593 arg1 = wxString_in_helper(obj0);
27594 if (arg1 == NULL) SWIG_fail;
27595 temp1 = true;
27596 }
27597 }
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27601
27602 wxPyEndAllowThreads(__tstate);
27603 if (PyErr_Occurred()) SWIG_fail;
27604 }
27605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27606 {
27607 if (temp1)
27608 delete arg1;
27609 }
27610 return resultobj;
27611 fail:
27612 {
27613 if (temp1)
27614 delete arg1;
27615 }
27616 return NULL;
27617 }
27618
27619
27620 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27621 PyObject *resultobj;
27622 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27623 size_t result;
27624 PyObject * obj0 = 0 ;
27625 char *kwnames[] = {
27626 (char *) "self", NULL
27627 };
27628
27629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27631 if (SWIG_arg_fail(1)) SWIG_fail;
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 result = (size_t)(arg1)->GetTextLength();
27635
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 {
27640 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27641 }
27642 return resultobj;
27643 fail:
27644 return NULL;
27645 }
27646
27647
27648 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27649 PyObject *resultobj;
27650 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27651 wxString result;
27652 PyObject * obj0 = 0 ;
27653 char *kwnames[] = {
27654 (char *) "self", NULL
27655 };
27656
27657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27659 if (SWIG_arg_fail(1)) SWIG_fail;
27660 {
27661 PyThreadState* __tstate = wxPyBeginAllowThreads();
27662 result = (arg1)->GetText();
27663
27664 wxPyEndAllowThreads(__tstate);
27665 if (PyErr_Occurred()) SWIG_fail;
27666 }
27667 {
27668 #if wxUSE_UNICODE
27669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27670 #else
27671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27672 #endif
27673 }
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27681 PyObject *resultobj;
27682 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27683 wxString *arg2 = 0 ;
27684 bool temp2 = false ;
27685 PyObject * obj0 = 0 ;
27686 PyObject * obj1 = 0 ;
27687 char *kwnames[] = {
27688 (char *) "self",(char *) "text", NULL
27689 };
27690
27691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27693 if (SWIG_arg_fail(1)) SWIG_fail;
27694 {
27695 arg2 = wxString_in_helper(obj1);
27696 if (arg2 == NULL) SWIG_fail;
27697 temp2 = true;
27698 }
27699 {
27700 PyThreadState* __tstate = wxPyBeginAllowThreads();
27701 (arg1)->SetText((wxString const &)*arg2);
27702
27703 wxPyEndAllowThreads(__tstate);
27704 if (PyErr_Occurred()) SWIG_fail;
27705 }
27706 Py_INCREF(Py_None); resultobj = Py_None;
27707 {
27708 if (temp2)
27709 delete arg2;
27710 }
27711 return resultobj;
27712 fail:
27713 {
27714 if (temp2)
27715 delete arg2;
27716 }
27717 return NULL;
27718 }
27719
27720
27721 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27722 PyObject *obj;
27723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27724 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27725 Py_INCREF(obj);
27726 return Py_BuildValue((char *)"");
27727 }
27728 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27729 PyObject *resultobj;
27730 wxString const &arg1_defvalue = wxPyEmptyString ;
27731 wxString *arg1 = (wxString *) &arg1_defvalue ;
27732 wxPyTextDataObject *result;
27733 bool temp1 = false ;
27734 PyObject * obj0 = 0 ;
27735 char *kwnames[] = {
27736 (char *) "text", NULL
27737 };
27738
27739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27740 if (obj0) {
27741 {
27742 arg1 = wxString_in_helper(obj0);
27743 if (arg1 == NULL) SWIG_fail;
27744 temp1 = true;
27745 }
27746 }
27747 {
27748 PyThreadState* __tstate = wxPyBeginAllowThreads();
27749 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27750
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27755 {
27756 if (temp1)
27757 delete arg1;
27758 }
27759 return resultobj;
27760 fail:
27761 {
27762 if (temp1)
27763 delete arg1;
27764 }
27765 return NULL;
27766 }
27767
27768
27769 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27770 PyObject *resultobj;
27771 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27772 PyObject *arg2 = (PyObject *) 0 ;
27773 PyObject *arg3 = (PyObject *) 0 ;
27774 PyObject * obj0 = 0 ;
27775 PyObject * obj1 = 0 ;
27776 PyObject * obj2 = 0 ;
27777 char *kwnames[] = {
27778 (char *) "self",(char *) "self",(char *) "_class", NULL
27779 };
27780
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 arg2 = obj1;
27785 arg3 = obj2;
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 (arg1)->_setCallbackInfo(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 * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27801 PyObject *obj;
27802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27803 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27804 Py_INCREF(obj);
27805 return Py_BuildValue((char *)"");
27806 }
27807 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27808 PyObject *resultobj;
27809 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27810 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27811 wxBitmapDataObject *result;
27812 PyObject * obj0 = 0 ;
27813 char *kwnames[] = {
27814 (char *) "bitmap", NULL
27815 };
27816
27817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27818 if (obj0) {
27819 {
27820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27821 if (SWIG_arg_fail(1)) SWIG_fail;
27822 if (arg1 == NULL) {
27823 SWIG_null_ref("wxBitmap");
27824 }
27825 if (SWIG_arg_fail(1)) SWIG_fail;
27826 }
27827 }
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27843 PyObject *resultobj;
27844 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27845 wxBitmap result;
27846 PyObject * obj0 = 0 ;
27847 char *kwnames[] = {
27848 (char *) "self", NULL
27849 };
27850
27851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27853 if (SWIG_arg_fail(1)) SWIG_fail;
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27857
27858 wxPyEndAllowThreads(__tstate);
27859 if (PyErr_Occurred()) SWIG_fail;
27860 }
27861 {
27862 wxBitmap * resultptr;
27863 resultptr = new wxBitmap((wxBitmap &)(result));
27864 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27865 }
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27873 PyObject *resultobj;
27874 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27875 wxBitmap *arg2 = 0 ;
27876 PyObject * obj0 = 0 ;
27877 PyObject * obj1 = 0 ;
27878 char *kwnames[] = {
27879 (char *) "self",(char *) "bitmap", NULL
27880 };
27881
27882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27884 if (SWIG_arg_fail(1)) SWIG_fail;
27885 {
27886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27887 if (SWIG_arg_fail(2)) SWIG_fail;
27888 if (arg2 == NULL) {
27889 SWIG_null_ref("wxBitmap");
27890 }
27891 if (SWIG_arg_fail(2)) SWIG_fail;
27892 }
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27896
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 Py_INCREF(Py_None); resultobj = Py_None;
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27908 PyObject *obj;
27909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27910 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27911 Py_INCREF(obj);
27912 return Py_BuildValue((char *)"");
27913 }
27914 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj;
27916 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27917 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27918 wxPyBitmapDataObject *result;
27919 PyObject * obj0 = 0 ;
27920 char *kwnames[] = {
27921 (char *) "bitmap", NULL
27922 };
27923
27924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27925 if (obj0) {
27926 {
27927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27928 if (SWIG_arg_fail(1)) SWIG_fail;
27929 if (arg1 == NULL) {
27930 SWIG_null_ref("wxBitmap");
27931 }
27932 if (SWIG_arg_fail(1)) SWIG_fail;
27933 }
27934 }
27935 {
27936 PyThreadState* __tstate = wxPyBeginAllowThreads();
27937 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27938
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27952 PyObject *arg2 = (PyObject *) 0 ;
27953 PyObject *arg3 = (PyObject *) 0 ;
27954 PyObject * obj0 = 0 ;
27955 PyObject * obj1 = 0 ;
27956 PyObject * obj2 = 0 ;
27957 char *kwnames[] = {
27958 (char *) "self",(char *) "self",(char *) "_class", NULL
27959 };
27960
27961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27963 if (SWIG_arg_fail(1)) SWIG_fail;
27964 arg2 = obj1;
27965 arg3 = obj2;
27966 {
27967 PyThreadState* __tstate = wxPyBeginAllowThreads();
27968 (arg1)->_setCallbackInfo(arg2,arg3);
27969
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 Py_INCREF(Py_None); resultobj = Py_None;
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27981 PyObject *obj;
27982 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27983 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27984 Py_INCREF(obj);
27985 return Py_BuildValue((char *)"");
27986 }
27987 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27988 PyObject *resultobj;
27989 wxFileDataObject *result;
27990 char *kwnames[] = {
27991 NULL
27992 };
27993
27994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27995 {
27996 PyThreadState* __tstate = wxPyBeginAllowThreads();
27997 result = (wxFileDataObject *)new wxFileDataObject();
27998
27999 wxPyEndAllowThreads(__tstate);
28000 if (PyErr_Occurred()) SWIG_fail;
28001 }
28002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28012 wxArrayString *result;
28013 PyObject * obj0 = 0 ;
28014 char *kwnames[] = {
28015 (char *) "self", NULL
28016 };
28017
28018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28020 if (SWIG_arg_fail(1)) SWIG_fail;
28021 {
28022 PyThreadState* __tstate = wxPyBeginAllowThreads();
28023 {
28024 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28025 result = (wxArrayString *) &_result_ref;
28026 }
28027
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 {
28032 resultobj = wxArrayString2PyList_helper(*result);
28033 }
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28041 PyObject *resultobj;
28042 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28043 wxString *arg2 = 0 ;
28044 bool temp2 = false ;
28045 PyObject * obj0 = 0 ;
28046 PyObject * obj1 = 0 ;
28047 char *kwnames[] = {
28048 (char *) "self",(char *) "filename", NULL
28049 };
28050
28051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28053 if (SWIG_arg_fail(1)) SWIG_fail;
28054 {
28055 arg2 = wxString_in_helper(obj1);
28056 if (arg2 == NULL) SWIG_fail;
28057 temp2 = true;
28058 }
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 (arg1)->AddFile((wxString const &)*arg2);
28062
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 Py_INCREF(Py_None); resultobj = Py_None;
28067 {
28068 if (temp2)
28069 delete arg2;
28070 }
28071 return resultobj;
28072 fail:
28073 {
28074 if (temp2)
28075 delete arg2;
28076 }
28077 return NULL;
28078 }
28079
28080
28081 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28082 PyObject *obj;
28083 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28084 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28085 Py_INCREF(obj);
28086 return Py_BuildValue((char *)"");
28087 }
28088 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28089 PyObject *resultobj;
28090 wxDataFormat *arg1 = 0 ;
28091 wxCustomDataObject *result;
28092 PyObject * obj0 = 0 ;
28093
28094 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28095 {
28096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28097 if (SWIG_arg_fail(1)) SWIG_fail;
28098 if (arg1 == NULL) {
28099 SWIG_null_ref("wxDataFormat");
28100 }
28101 if (SWIG_arg_fail(1)) SWIG_fail;
28102 }
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28118 PyObject *resultobj;
28119 wxString *arg1 = 0 ;
28120 wxCustomDataObject *result;
28121 bool temp1 = false ;
28122 PyObject * obj0 = 0 ;
28123
28124 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28125 {
28126 arg1 = wxString_in_helper(obj0);
28127 if (arg1 == NULL) SWIG_fail;
28128 temp1 = true;
28129 }
28130 {
28131 PyThreadState* __tstate = wxPyBeginAllowThreads();
28132 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28133
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28138 {
28139 if (temp1)
28140 delete arg1;
28141 }
28142 return resultobj;
28143 fail:
28144 {
28145 if (temp1)
28146 delete arg1;
28147 }
28148 return NULL;
28149 }
28150
28151
28152 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28153 PyObject *resultobj;
28154 wxCustomDataObject *result;
28155
28156 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 result = (wxCustomDataObject *)new wxCustomDataObject();
28160
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28165 return resultobj;
28166 fail:
28167 return NULL;
28168 }
28169
28170
28171 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28172 int argc;
28173 PyObject *argv[2];
28174 int ii;
28175
28176 argc = PyObject_Length(args);
28177 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28178 argv[ii] = PyTuple_GetItem(args,ii);
28179 }
28180 if (argc == 0) {
28181 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28182 }
28183 if (argc == 1) {
28184 int _v;
28185 {
28186 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28187 }
28188 if (_v) {
28189 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28190 }
28191 }
28192 if (argc == 1) {
28193 int _v;
28194 {
28195 void *ptr = 0;
28196 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28197 _v = 0;
28198 PyErr_Clear();
28199 } else {
28200 _v = (ptr != 0);
28201 }
28202 }
28203 if (_v) {
28204 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28205 }
28206 }
28207
28208 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28209 return NULL;
28210 }
28211
28212
28213 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj;
28215 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28216 PyObject *arg2 = (PyObject *) 0 ;
28217 bool result;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char *kwnames[] = {
28221 (char *) "self",(char *) "data", NULL
28222 };
28223
28224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28226 if (SWIG_arg_fail(1)) SWIG_fail;
28227 arg2 = obj1;
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 {
28236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28237 }
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj;
28246 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28247 size_t result;
28248 PyObject * obj0 = 0 ;
28249 char *kwnames[] = {
28250 (char *) "self", NULL
28251 };
28252
28253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28255 if (SWIG_arg_fail(1)) SWIG_fail;
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (size_t)(arg1)->GetSize();
28259
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj;
28274 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28275 PyObject *result;
28276 PyObject * obj0 = 0 ;
28277 char *kwnames[] = {
28278 (char *) "self", NULL
28279 };
28280
28281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28283 if (SWIG_arg_fail(1)) SWIG_fail;
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28287
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 resultobj = result;
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28299 PyObject *obj;
28300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28301 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28302 Py_INCREF(obj);
28303 return Py_BuildValue((char *)"");
28304 }
28305 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28306 PyObject *resultobj;
28307 wxURLDataObject *result;
28308 char *kwnames[] = {
28309 NULL
28310 };
28311
28312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 result = (wxURLDataObject *)new wxURLDataObject();
28316
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28328 PyObject *resultobj;
28329 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28330 wxString result;
28331 PyObject * obj0 = 0 ;
28332 char *kwnames[] = {
28333 (char *) "self", NULL
28334 };
28335
28336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(1)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (arg1)->GetURL();
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 {
28347 #if wxUSE_UNICODE
28348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28349 #else
28350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28351 #endif
28352 }
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28362 wxString *arg2 = 0 ;
28363 bool temp2 = false ;
28364 PyObject * obj0 = 0 ;
28365 PyObject * obj1 = 0 ;
28366 char *kwnames[] = {
28367 (char *) "self",(char *) "url", NULL
28368 };
28369
28370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28372 if (SWIG_arg_fail(1)) SWIG_fail;
28373 {
28374 arg2 = wxString_in_helper(obj1);
28375 if (arg2 == NULL) SWIG_fail;
28376 temp2 = true;
28377 }
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 (arg1)->SetURL((wxString const &)*arg2);
28381
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 Py_INCREF(Py_None); resultobj = Py_None;
28386 {
28387 if (temp2)
28388 delete arg2;
28389 }
28390 return resultobj;
28391 fail:
28392 {
28393 if (temp2)
28394 delete arg2;
28395 }
28396 return NULL;
28397 }
28398
28399
28400 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28401 PyObject *obj;
28402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28403 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28404 Py_INCREF(obj);
28405 return Py_BuildValue((char *)"");
28406 }
28407 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28408 PyObject *resultobj;
28409 wxMetafileDataObject *result;
28410 char *kwnames[] = {
28411 NULL
28412 };
28413
28414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28415 {
28416 PyThreadState* __tstate = wxPyBeginAllowThreads();
28417 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28418
28419 wxPyEndAllowThreads(__tstate);
28420 if (PyErr_Occurred()) SWIG_fail;
28421 }
28422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28423 return resultobj;
28424 fail:
28425 return NULL;
28426 }
28427
28428
28429 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28430 PyObject *resultobj;
28431 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28432 wxMetafile *arg2 = 0 ;
28433 PyObject * obj0 = 0 ;
28434 PyObject * obj1 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self",(char *) "metafile", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28441 if (SWIG_arg_fail(1)) SWIG_fail;
28442 {
28443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28444 if (SWIG_arg_fail(2)) SWIG_fail;
28445 if (arg2 == NULL) {
28446 SWIG_null_ref("wxMetafile");
28447 }
28448 if (SWIG_arg_fail(2)) SWIG_fail;
28449 }
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28453
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 Py_INCREF(Py_None); resultobj = Py_None;
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj;
28466 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28467 wxMetafile result;
28468 PyObject * obj0 = 0 ;
28469 char *kwnames[] = {
28470 (char *) "self", NULL
28471 };
28472
28473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28475 if (SWIG_arg_fail(1)) SWIG_fail;
28476 {
28477 PyThreadState* __tstate = wxPyBeginAllowThreads();
28478 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28479
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 {
28484 wxMetafile * resultptr;
28485 resultptr = new wxMetafile((wxMetafile &)(result));
28486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28487 }
28488 return resultobj;
28489 fail:
28490 return NULL;
28491 }
28492
28493
28494 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28495 PyObject *obj;
28496 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28497 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28498 Py_INCREF(obj);
28499 return Py_BuildValue((char *)"");
28500 }
28501 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28502 PyObject *resultobj;
28503 wxDragResult arg1 ;
28504 bool result;
28505 PyObject * obj0 = 0 ;
28506 char *kwnames[] = {
28507 (char *) "res", NULL
28508 };
28509
28510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28511 {
28512 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28513 if (SWIG_arg_fail(1)) SWIG_fail;
28514 }
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28518
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 {
28523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28524 }
28525 return resultobj;
28526 fail:
28527 return NULL;
28528 }
28529
28530
28531 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj;
28533 wxWindow *arg1 = (wxWindow *) 0 ;
28534 wxCursor const &arg2_defvalue = wxNullCursor ;
28535 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28536 wxCursor const &arg3_defvalue = wxNullCursor ;
28537 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28538 wxCursor const &arg4_defvalue = wxNullCursor ;
28539 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28540 wxPyDropSource *result;
28541 PyObject * obj0 = 0 ;
28542 PyObject * obj1 = 0 ;
28543 PyObject * obj2 = 0 ;
28544 PyObject * obj3 = 0 ;
28545 char *kwnames[] = {
28546 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28547 };
28548
28549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28551 if (SWIG_arg_fail(1)) SWIG_fail;
28552 if (obj1) {
28553 {
28554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(2)) SWIG_fail;
28556 if (arg2 == NULL) {
28557 SWIG_null_ref("wxCursor");
28558 }
28559 if (SWIG_arg_fail(2)) SWIG_fail;
28560 }
28561 }
28562 if (obj2) {
28563 {
28564 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28565 if (SWIG_arg_fail(3)) SWIG_fail;
28566 if (arg3 == NULL) {
28567 SWIG_null_ref("wxCursor");
28568 }
28569 if (SWIG_arg_fail(3)) SWIG_fail;
28570 }
28571 }
28572 if (obj3) {
28573 {
28574 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28575 if (SWIG_arg_fail(4)) SWIG_fail;
28576 if (arg4 == NULL) {
28577 SWIG_null_ref("wxCursor");
28578 }
28579 if (SWIG_arg_fail(4)) SWIG_fail;
28580 }
28581 }
28582 {
28583 PyThreadState* __tstate = wxPyBeginAllowThreads();
28584 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28585
28586 wxPyEndAllowThreads(__tstate);
28587 if (PyErr_Occurred()) SWIG_fail;
28588 }
28589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28597 PyObject *resultobj;
28598 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28599 PyObject *arg2 = (PyObject *) 0 ;
28600 PyObject *arg3 = (PyObject *) 0 ;
28601 int arg4 ;
28602 PyObject * obj0 = 0 ;
28603 PyObject * obj1 = 0 ;
28604 PyObject * obj2 = 0 ;
28605 PyObject * obj3 = 0 ;
28606 char *kwnames[] = {
28607 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28608 };
28609
28610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28612 if (SWIG_arg_fail(1)) SWIG_fail;
28613 arg2 = obj1;
28614 arg3 = obj2;
28615 {
28616 arg4 = (int)(SWIG_As_int(obj3));
28617 if (SWIG_arg_fail(4)) SWIG_fail;
28618 }
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28622
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 Py_INCREF(Py_None); resultobj = Py_None;
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj;
28635 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28636 PyObject * obj0 = 0 ;
28637 char *kwnames[] = {
28638 (char *) "self", NULL
28639 };
28640
28641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28643 if (SWIG_arg_fail(1)) SWIG_fail;
28644 {
28645 PyThreadState* __tstate = wxPyBeginAllowThreads();
28646 delete arg1;
28647
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 Py_INCREF(Py_None); resultobj = Py_None;
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28659 PyObject *resultobj;
28660 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28661 wxDataObject *arg2 = 0 ;
28662 PyObject * obj0 = 0 ;
28663 PyObject * obj1 = 0 ;
28664 char *kwnames[] = {
28665 (char *) "self",(char *) "data", NULL
28666 };
28667
28668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28670 if (SWIG_arg_fail(1)) SWIG_fail;
28671 {
28672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28673 if (SWIG_arg_fail(2)) SWIG_fail;
28674 if (arg2 == NULL) {
28675 SWIG_null_ref("wxDataObject");
28676 }
28677 if (SWIG_arg_fail(2)) SWIG_fail;
28678 }
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 (arg1)->SetData(*arg2);
28682
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 Py_INCREF(Py_None); resultobj = Py_None;
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28694 PyObject *resultobj;
28695 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28696 wxDataObject *result;
28697 PyObject * obj0 = 0 ;
28698 char *kwnames[] = {
28699 (char *) "self", NULL
28700 };
28701
28702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28704 if (SWIG_arg_fail(1)) SWIG_fail;
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 result = (wxDataObject *)(arg1)->GetDataObject();
28708
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj;
28721 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28722 wxDragResult arg2 ;
28723 wxCursor *arg3 = 0 ;
28724 PyObject * obj0 = 0 ;
28725 PyObject * obj1 = 0 ;
28726 PyObject * obj2 = 0 ;
28727 char *kwnames[] = {
28728 (char *) "self",(char *) "res",(char *) "cursor", NULL
28729 };
28730
28731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28733 if (SWIG_arg_fail(1)) SWIG_fail;
28734 {
28735 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28736 if (SWIG_arg_fail(2)) SWIG_fail;
28737 }
28738 {
28739 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(3)) SWIG_fail;
28741 if (arg3 == NULL) {
28742 SWIG_null_ref("wxCursor");
28743 }
28744 if (SWIG_arg_fail(3)) SWIG_fail;
28745 }
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28749
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 Py_INCREF(Py_None); resultobj = Py_None;
28754 return resultobj;
28755 fail:
28756 return NULL;
28757 }
28758
28759
28760 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28761 PyObject *resultobj;
28762 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28763 int arg2 = (int) wxDrag_CopyOnly ;
28764 wxDragResult result;
28765 PyObject * obj0 = 0 ;
28766 PyObject * obj1 = 0 ;
28767 char *kwnames[] = {
28768 (char *) "self",(char *) "flags", NULL
28769 };
28770
28771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28773 if (SWIG_arg_fail(1)) SWIG_fail;
28774 if (obj1) {
28775 {
28776 arg2 = (int)(SWIG_As_int(obj1));
28777 if (SWIG_arg_fail(2)) SWIG_fail;
28778 }
28779 }
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28783
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 resultobj = SWIG_From_int((result));
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28797 wxDragResult arg2 ;
28798 bool result;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 char *kwnames[] = {
28802 (char *) "self",(char *) "effect", NULL
28803 };
28804
28805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28807 if (SWIG_arg_fail(1)) SWIG_fail;
28808 {
28809 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28810 if (SWIG_arg_fail(2)) SWIG_fail;
28811 }
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28815
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 {
28820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28821 }
28822 return resultobj;
28823 fail:
28824 return NULL;
28825 }
28826
28827
28828 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28829 PyObject *obj;
28830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28831 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28832 Py_INCREF(obj);
28833 return Py_BuildValue((char *)"");
28834 }
28835 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj;
28837 wxDataObject *arg1 = (wxDataObject *) NULL ;
28838 wxPyDropTarget *result;
28839 PyObject * obj0 = 0 ;
28840 char *kwnames[] = {
28841 (char *) "dataObject", NULL
28842 };
28843
28844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28845 if (obj0) {
28846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28847 if (SWIG_arg_fail(1)) SWIG_fail;
28848 }
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28852
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj;
28865 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28866 PyObject *arg2 = (PyObject *) 0 ;
28867 PyObject *arg3 = (PyObject *) 0 ;
28868 PyObject * obj0 = 0 ;
28869 PyObject * obj1 = 0 ;
28870 PyObject * obj2 = 0 ;
28871 char *kwnames[] = {
28872 (char *) "self",(char *) "self",(char *) "_class", NULL
28873 };
28874
28875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28877 if (SWIG_arg_fail(1)) SWIG_fail;
28878 arg2 = obj1;
28879 arg3 = obj2;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 (arg1)->_setCallbackInfo(arg2,arg3);
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 Py_INCREF(Py_None); resultobj = Py_None;
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28895 PyObject *resultobj;
28896 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28897 PyObject * obj0 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28904 if (SWIG_arg_fail(1)) SWIG_fail;
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 delete arg1;
28908
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 Py_INCREF(Py_None); resultobj = Py_None;
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28920 PyObject *resultobj;
28921 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28922 wxDataObject *result;
28923 PyObject * obj0 = 0 ;
28924 char *kwnames[] = {
28925 (char *) "self", NULL
28926 };
28927
28928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28930 if (SWIG_arg_fail(1)) SWIG_fail;
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 result = (wxDataObject *)(arg1)->GetDataObject();
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28946 PyObject *resultobj;
28947 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28948 wxDataObject *arg2 = (wxDataObject *) 0 ;
28949 PyObject * obj0 = 0 ;
28950 PyObject * obj1 = 0 ;
28951 char *kwnames[] = {
28952 (char *) "self",(char *) "dataObject", NULL
28953 };
28954
28955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28957 if (SWIG_arg_fail(1)) SWIG_fail;
28958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28959 if (SWIG_arg_fail(2)) SWIG_fail;
28960 {
28961 PyThreadState* __tstate = wxPyBeginAllowThreads();
28962 (arg1)->SetDataObject(arg2);
28963
28964 wxPyEndAllowThreads(__tstate);
28965 if (PyErr_Occurred()) SWIG_fail;
28966 }
28967 Py_INCREF(Py_None); resultobj = Py_None;
28968 return resultobj;
28969 fail:
28970 return NULL;
28971 }
28972
28973
28974 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28975 PyObject *resultobj;
28976 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28977 int arg2 ;
28978 int arg3 ;
28979 wxDragResult arg4 ;
28980 wxDragResult result;
28981 PyObject * obj0 = 0 ;
28982 PyObject * obj1 = 0 ;
28983 PyObject * obj2 = 0 ;
28984 PyObject * obj3 = 0 ;
28985 char *kwnames[] = {
28986 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28987 };
28988
28989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28991 if (SWIG_arg_fail(1)) SWIG_fail;
28992 {
28993 arg2 = (int)(SWIG_As_int(obj1));
28994 if (SWIG_arg_fail(2)) SWIG_fail;
28995 }
28996 {
28997 arg3 = (int)(SWIG_As_int(obj2));
28998 if (SWIG_arg_fail(3)) SWIG_fail;
28999 }
29000 {
29001 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29002 if (SWIG_arg_fail(4)) SWIG_fail;
29003 }
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29007
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 resultobj = SWIG_From_int((result));
29012 return resultobj;
29013 fail:
29014 return NULL;
29015 }
29016
29017
29018 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29019 PyObject *resultobj;
29020 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29021 int arg2 ;
29022 int arg3 ;
29023 wxDragResult arg4 ;
29024 wxDragResult result;
29025 PyObject * obj0 = 0 ;
29026 PyObject * obj1 = 0 ;
29027 PyObject * obj2 = 0 ;
29028 PyObject * obj3 = 0 ;
29029 char *kwnames[] = {
29030 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29031 };
29032
29033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29035 if (SWIG_arg_fail(1)) SWIG_fail;
29036 {
29037 arg2 = (int)(SWIG_As_int(obj1));
29038 if (SWIG_arg_fail(2)) SWIG_fail;
29039 }
29040 {
29041 arg3 = (int)(SWIG_As_int(obj2));
29042 if (SWIG_arg_fail(3)) SWIG_fail;
29043 }
29044 {
29045 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29046 if (SWIG_arg_fail(4)) SWIG_fail;
29047 }
29048 {
29049 PyThreadState* __tstate = wxPyBeginAllowThreads();
29050 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29051
29052 wxPyEndAllowThreads(__tstate);
29053 if (PyErr_Occurred()) SWIG_fail;
29054 }
29055 resultobj = SWIG_From_int((result));
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj;
29064 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29065 PyObject * obj0 = 0 ;
29066 char *kwnames[] = {
29067 (char *) "self", NULL
29068 };
29069
29070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29072 if (SWIG_arg_fail(1)) SWIG_fail;
29073 {
29074 PyThreadState* __tstate = wxPyBeginAllowThreads();
29075 (arg1)->base_OnLeave();
29076
29077 wxPyEndAllowThreads(__tstate);
29078 if (PyErr_Occurred()) SWIG_fail;
29079 }
29080 Py_INCREF(Py_None); resultobj = Py_None;
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29088 PyObject *resultobj;
29089 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29090 int arg2 ;
29091 int arg3 ;
29092 bool result;
29093 PyObject * obj0 = 0 ;
29094 PyObject * obj1 = 0 ;
29095 PyObject * obj2 = 0 ;
29096 char *kwnames[] = {
29097 (char *) "self",(char *) "x",(char *) "y", NULL
29098 };
29099
29100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29102 if (SWIG_arg_fail(1)) SWIG_fail;
29103 {
29104 arg2 = (int)(SWIG_As_int(obj1));
29105 if (SWIG_arg_fail(2)) SWIG_fail;
29106 }
29107 {
29108 arg3 = (int)(SWIG_As_int(obj2));
29109 if (SWIG_arg_fail(3)) SWIG_fail;
29110 }
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29114
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 {
29119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29120 }
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj;
29129 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29130 bool result;
29131 PyObject * obj0 = 0 ;
29132 char *kwnames[] = {
29133 (char *) "self", NULL
29134 };
29135
29136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29138 if (SWIG_arg_fail(1)) SWIG_fail;
29139 {
29140 PyThreadState* __tstate = wxPyBeginAllowThreads();
29141 result = (bool)(arg1)->GetData();
29142
29143 wxPyEndAllowThreads(__tstate);
29144 if (PyErr_Occurred()) SWIG_fail;
29145 }
29146 {
29147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29148 }
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29156 PyObject *obj;
29157 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29158 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29159 Py_INCREF(obj);
29160 return Py_BuildValue((char *)"");
29161 }
29162 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29163 PyObject *resultobj;
29164 wxPyTextDropTarget *result;
29165 char *kwnames[] = {
29166 NULL
29167 };
29168
29169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29173
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj;
29186 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29187 PyObject *arg2 = (PyObject *) 0 ;
29188 PyObject *arg3 = (PyObject *) 0 ;
29189 PyObject * obj0 = 0 ;
29190 PyObject * obj1 = 0 ;
29191 PyObject * obj2 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "self",(char *) "self",(char *) "_class", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29198 if (SWIG_arg_fail(1)) SWIG_fail;
29199 arg2 = obj1;
29200 arg3 = obj2;
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 (arg1)->_setCallbackInfo(arg2,arg3);
29204
29205 wxPyEndAllowThreads(__tstate);
29206 if (PyErr_Occurred()) SWIG_fail;
29207 }
29208 Py_INCREF(Py_None); resultobj = Py_None;
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29216 PyObject *resultobj;
29217 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29218 int arg2 ;
29219 int arg3 ;
29220 wxDragResult arg4 ;
29221 wxDragResult result;
29222 PyObject * obj0 = 0 ;
29223 PyObject * obj1 = 0 ;
29224 PyObject * obj2 = 0 ;
29225 PyObject * obj3 = 0 ;
29226 char *kwnames[] = {
29227 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29228 };
29229
29230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29232 if (SWIG_arg_fail(1)) SWIG_fail;
29233 {
29234 arg2 = (int)(SWIG_As_int(obj1));
29235 if (SWIG_arg_fail(2)) SWIG_fail;
29236 }
29237 {
29238 arg3 = (int)(SWIG_As_int(obj2));
29239 if (SWIG_arg_fail(3)) SWIG_fail;
29240 }
29241 {
29242 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29243 if (SWIG_arg_fail(4)) SWIG_fail;
29244 }
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29248
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_From_int((result));
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj;
29261 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29262 int arg2 ;
29263 int arg3 ;
29264 wxDragResult arg4 ;
29265 wxDragResult result;
29266 PyObject * obj0 = 0 ;
29267 PyObject * obj1 = 0 ;
29268 PyObject * obj2 = 0 ;
29269 PyObject * obj3 = 0 ;
29270 char *kwnames[] = {
29271 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29272 };
29273
29274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29276 if (SWIG_arg_fail(1)) SWIG_fail;
29277 {
29278 arg2 = (int)(SWIG_As_int(obj1));
29279 if (SWIG_arg_fail(2)) SWIG_fail;
29280 }
29281 {
29282 arg3 = (int)(SWIG_As_int(obj2));
29283 if (SWIG_arg_fail(3)) SWIG_fail;
29284 }
29285 {
29286 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29287 if (SWIG_arg_fail(4)) SWIG_fail;
29288 }
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29292
29293 wxPyEndAllowThreads(__tstate);
29294 if (PyErr_Occurred()) SWIG_fail;
29295 }
29296 resultobj = SWIG_From_int((result));
29297 return resultobj;
29298 fail:
29299 return NULL;
29300 }
29301
29302
29303 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29304 PyObject *resultobj;
29305 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29306 PyObject * obj0 = 0 ;
29307 char *kwnames[] = {
29308 (char *) "self", NULL
29309 };
29310
29311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29313 if (SWIG_arg_fail(1)) SWIG_fail;
29314 {
29315 PyThreadState* __tstate = wxPyBeginAllowThreads();
29316 (arg1)->base_OnLeave();
29317
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 Py_INCREF(Py_None); resultobj = Py_None;
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29329 PyObject *resultobj;
29330 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29331 int arg2 ;
29332 int arg3 ;
29333 bool result;
29334 PyObject * obj0 = 0 ;
29335 PyObject * obj1 = 0 ;
29336 PyObject * obj2 = 0 ;
29337 char *kwnames[] = {
29338 (char *) "self",(char *) "x",(char *) "y", NULL
29339 };
29340
29341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29343 if (SWIG_arg_fail(1)) SWIG_fail;
29344 {
29345 arg2 = (int)(SWIG_As_int(obj1));
29346 if (SWIG_arg_fail(2)) SWIG_fail;
29347 }
29348 {
29349 arg3 = (int)(SWIG_As_int(obj2));
29350 if (SWIG_arg_fail(3)) SWIG_fail;
29351 }
29352 {
29353 PyThreadState* __tstate = wxPyBeginAllowThreads();
29354 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29355
29356 wxPyEndAllowThreads(__tstate);
29357 if (PyErr_Occurred()) SWIG_fail;
29358 }
29359 {
29360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29361 }
29362 return resultobj;
29363 fail:
29364 return NULL;
29365 }
29366
29367
29368 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29369 PyObject *resultobj;
29370 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29371 int arg2 ;
29372 int arg3 ;
29373 wxDragResult arg4 ;
29374 wxDragResult result;
29375 PyObject * obj0 = 0 ;
29376 PyObject * obj1 = 0 ;
29377 PyObject * obj2 = 0 ;
29378 PyObject * obj3 = 0 ;
29379 char *kwnames[] = {
29380 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29381 };
29382
29383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29385 if (SWIG_arg_fail(1)) SWIG_fail;
29386 {
29387 arg2 = (int)(SWIG_As_int(obj1));
29388 if (SWIG_arg_fail(2)) SWIG_fail;
29389 }
29390 {
29391 arg3 = (int)(SWIG_As_int(obj2));
29392 if (SWIG_arg_fail(3)) SWIG_fail;
29393 }
29394 {
29395 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29396 if (SWIG_arg_fail(4)) SWIG_fail;
29397 }
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 resultobj = SWIG_From_int((result));
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29413 PyObject *obj;
29414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29415 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29416 Py_INCREF(obj);
29417 return Py_BuildValue((char *)"");
29418 }
29419 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29420 PyObject *resultobj;
29421 wxPyFileDropTarget *result;
29422 char *kwnames[] = {
29423 NULL
29424 };
29425
29426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29430
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj;
29443 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29444 PyObject *arg2 = (PyObject *) 0 ;
29445 PyObject *arg3 = (PyObject *) 0 ;
29446 PyObject * obj0 = 0 ;
29447 PyObject * obj1 = 0 ;
29448 PyObject * obj2 = 0 ;
29449 char *kwnames[] = {
29450 (char *) "self",(char *) "self",(char *) "_class", NULL
29451 };
29452
29453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29455 if (SWIG_arg_fail(1)) SWIG_fail;
29456 arg2 = obj1;
29457 arg3 = obj2;
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 (arg1)->_setCallbackInfo(arg2,arg3);
29461
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 Py_INCREF(Py_None); resultobj = Py_None;
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj;
29474 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29475 int arg2 ;
29476 int arg3 ;
29477 wxDragResult arg4 ;
29478 wxDragResult result;
29479 PyObject * obj0 = 0 ;
29480 PyObject * obj1 = 0 ;
29481 PyObject * obj2 = 0 ;
29482 PyObject * obj3 = 0 ;
29483 char *kwnames[] = {
29484 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29485 };
29486
29487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29489 if (SWIG_arg_fail(1)) SWIG_fail;
29490 {
29491 arg2 = (int)(SWIG_As_int(obj1));
29492 if (SWIG_arg_fail(2)) SWIG_fail;
29493 }
29494 {
29495 arg3 = (int)(SWIG_As_int(obj2));
29496 if (SWIG_arg_fail(3)) SWIG_fail;
29497 }
29498 {
29499 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29500 if (SWIG_arg_fail(4)) SWIG_fail;
29501 }
29502 {
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29505
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 resultobj = SWIG_From_int((result));
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj;
29518 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29519 int arg2 ;
29520 int arg3 ;
29521 wxDragResult arg4 ;
29522 wxDragResult result;
29523 PyObject * obj0 = 0 ;
29524 PyObject * obj1 = 0 ;
29525 PyObject * obj2 = 0 ;
29526 PyObject * obj3 = 0 ;
29527 char *kwnames[] = {
29528 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29529 };
29530
29531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29533 if (SWIG_arg_fail(1)) SWIG_fail;
29534 {
29535 arg2 = (int)(SWIG_As_int(obj1));
29536 if (SWIG_arg_fail(2)) SWIG_fail;
29537 }
29538 {
29539 arg3 = (int)(SWIG_As_int(obj2));
29540 if (SWIG_arg_fail(3)) SWIG_fail;
29541 }
29542 {
29543 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29544 if (SWIG_arg_fail(4)) SWIG_fail;
29545 }
29546 {
29547 PyThreadState* __tstate = wxPyBeginAllowThreads();
29548 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29549
29550 wxPyEndAllowThreads(__tstate);
29551 if (PyErr_Occurred()) SWIG_fail;
29552 }
29553 resultobj = SWIG_From_int((result));
29554 return resultobj;
29555 fail:
29556 return NULL;
29557 }
29558
29559
29560 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29561 PyObject *resultobj;
29562 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29563 PyObject * obj0 = 0 ;
29564 char *kwnames[] = {
29565 (char *) "self", NULL
29566 };
29567
29568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29570 if (SWIG_arg_fail(1)) SWIG_fail;
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 (arg1)->base_OnLeave();
29574
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 Py_INCREF(Py_None); resultobj = Py_None;
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29586 PyObject *resultobj;
29587 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29588 int arg2 ;
29589 int arg3 ;
29590 bool result;
29591 PyObject * obj0 = 0 ;
29592 PyObject * obj1 = 0 ;
29593 PyObject * obj2 = 0 ;
29594 char *kwnames[] = {
29595 (char *) "self",(char *) "x",(char *) "y", NULL
29596 };
29597
29598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29600 if (SWIG_arg_fail(1)) SWIG_fail;
29601 {
29602 arg2 = (int)(SWIG_As_int(obj1));
29603 if (SWIG_arg_fail(2)) SWIG_fail;
29604 }
29605 {
29606 arg3 = (int)(SWIG_As_int(obj2));
29607 if (SWIG_arg_fail(3)) SWIG_fail;
29608 }
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29612
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 {
29617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29618 }
29619 return resultobj;
29620 fail:
29621 return NULL;
29622 }
29623
29624
29625 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj;
29627 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29628 int arg2 ;
29629 int arg3 ;
29630 wxDragResult arg4 ;
29631 wxDragResult result;
29632 PyObject * obj0 = 0 ;
29633 PyObject * obj1 = 0 ;
29634 PyObject * obj2 = 0 ;
29635 PyObject * obj3 = 0 ;
29636 char *kwnames[] = {
29637 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29638 };
29639
29640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29642 if (SWIG_arg_fail(1)) SWIG_fail;
29643 {
29644 arg2 = (int)(SWIG_As_int(obj1));
29645 if (SWIG_arg_fail(2)) SWIG_fail;
29646 }
29647 {
29648 arg3 = (int)(SWIG_As_int(obj2));
29649 if (SWIG_arg_fail(3)) SWIG_fail;
29650 }
29651 {
29652 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29653 if (SWIG_arg_fail(4)) SWIG_fail;
29654 }
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29658
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 resultobj = SWIG_From_int((result));
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29670 PyObject *obj;
29671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29672 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29673 Py_INCREF(obj);
29674 return Py_BuildValue((char *)"");
29675 }
29676 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29677 PyObject *resultobj;
29678 wxClipboard *result;
29679 char *kwnames[] = {
29680 NULL
29681 };
29682
29683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (wxClipboard *)new wxClipboard();
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj;
29700 wxClipboard *arg1 = (wxClipboard *) 0 ;
29701 PyObject * obj0 = 0 ;
29702 char *kwnames[] = {
29703 (char *) "self", NULL
29704 };
29705
29706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29708 if (SWIG_arg_fail(1)) SWIG_fail;
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 delete arg1;
29712
29713 wxPyEndAllowThreads(__tstate);
29714 if (PyErr_Occurred()) SWIG_fail;
29715 }
29716 Py_INCREF(Py_None); resultobj = Py_None;
29717 return resultobj;
29718 fail:
29719 return NULL;
29720 }
29721
29722
29723 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29724 PyObject *resultobj;
29725 wxClipboard *arg1 = (wxClipboard *) 0 ;
29726 bool result;
29727 PyObject * obj0 = 0 ;
29728 char *kwnames[] = {
29729 (char *) "self", NULL
29730 };
29731
29732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29734 if (SWIG_arg_fail(1)) SWIG_fail;
29735 {
29736 PyThreadState* __tstate = wxPyBeginAllowThreads();
29737 result = (bool)(arg1)->Open();
29738
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 {
29743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29744 }
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj;
29753 wxClipboard *arg1 = (wxClipboard *) 0 ;
29754 PyObject * obj0 = 0 ;
29755 char *kwnames[] = {
29756 (char *) "self", NULL
29757 };
29758
29759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29761 if (SWIG_arg_fail(1)) SWIG_fail;
29762 {
29763 PyThreadState* __tstate = wxPyBeginAllowThreads();
29764 (arg1)->Close();
29765
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 Py_INCREF(Py_None); resultobj = Py_None;
29770 return resultobj;
29771 fail:
29772 return NULL;
29773 }
29774
29775
29776 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29777 PyObject *resultobj;
29778 wxClipboard *arg1 = (wxClipboard *) 0 ;
29779 bool result;
29780 PyObject * obj0 = 0 ;
29781 char *kwnames[] = {
29782 (char *) "self", NULL
29783 };
29784
29785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29787 if (SWIG_arg_fail(1)) SWIG_fail;
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 {
29796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29797 }
29798 return resultobj;
29799 fail:
29800 return NULL;
29801 }
29802
29803
29804 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29805 PyObject *resultobj;
29806 wxClipboard *arg1 = (wxClipboard *) 0 ;
29807 wxDataObject *arg2 = (wxDataObject *) 0 ;
29808 bool result;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 char *kwnames[] = {
29812 (char *) "self",(char *) "data", NULL
29813 };
29814
29815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29817 if (SWIG_arg_fail(1)) SWIG_fail;
29818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29819 if (SWIG_arg_fail(2)) SWIG_fail;
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 result = (bool)(arg1)->AddData(arg2);
29823
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 {
29828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29829 }
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29837 PyObject *resultobj;
29838 wxClipboard *arg1 = (wxClipboard *) 0 ;
29839 wxDataObject *arg2 = (wxDataObject *) 0 ;
29840 bool result;
29841 PyObject * obj0 = 0 ;
29842 PyObject * obj1 = 0 ;
29843 char *kwnames[] = {
29844 (char *) "self",(char *) "data", NULL
29845 };
29846
29847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29849 if (SWIG_arg_fail(1)) SWIG_fail;
29850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29851 if (SWIG_arg_fail(2)) SWIG_fail;
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (bool)(arg1)->SetData(arg2);
29855
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 {
29860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29861 }
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj;
29870 wxClipboard *arg1 = (wxClipboard *) 0 ;
29871 wxDataFormat *arg2 = 0 ;
29872 bool result;
29873 PyObject * obj0 = 0 ;
29874 PyObject * obj1 = 0 ;
29875 char *kwnames[] = {
29876 (char *) "self",(char *) "format", NULL
29877 };
29878
29879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29881 if (SWIG_arg_fail(1)) SWIG_fail;
29882 {
29883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29884 if (SWIG_arg_fail(2)) SWIG_fail;
29885 if (arg2 == NULL) {
29886 SWIG_null_ref("wxDataFormat");
29887 }
29888 if (SWIG_arg_fail(2)) SWIG_fail;
29889 }
29890 {
29891 PyThreadState* __tstate = wxPyBeginAllowThreads();
29892 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29893
29894 wxPyEndAllowThreads(__tstate);
29895 if (PyErr_Occurred()) SWIG_fail;
29896 }
29897 {
29898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29899 }
29900 return resultobj;
29901 fail:
29902 return NULL;
29903 }
29904
29905
29906 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29907 PyObject *resultobj;
29908 wxClipboard *arg1 = (wxClipboard *) 0 ;
29909 wxDataObject *arg2 = 0 ;
29910 bool result;
29911 PyObject * obj0 = 0 ;
29912 PyObject * obj1 = 0 ;
29913 char *kwnames[] = {
29914 (char *) "self",(char *) "data", NULL
29915 };
29916
29917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29919 if (SWIG_arg_fail(1)) SWIG_fail;
29920 {
29921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29922 if (SWIG_arg_fail(2)) SWIG_fail;
29923 if (arg2 == NULL) {
29924 SWIG_null_ref("wxDataObject");
29925 }
29926 if (SWIG_arg_fail(2)) SWIG_fail;
29927 }
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 result = (bool)(arg1)->GetData(*arg2);
29931
29932 wxPyEndAllowThreads(__tstate);
29933 if (PyErr_Occurred()) SWIG_fail;
29934 }
29935 {
29936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29937 }
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29945 PyObject *resultobj;
29946 wxClipboard *arg1 = (wxClipboard *) 0 ;
29947 PyObject * obj0 = 0 ;
29948 char *kwnames[] = {
29949 (char *) "self", NULL
29950 };
29951
29952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29954 if (SWIG_arg_fail(1)) SWIG_fail;
29955 {
29956 PyThreadState* __tstate = wxPyBeginAllowThreads();
29957 (arg1)->Clear();
29958
29959 wxPyEndAllowThreads(__tstate);
29960 if (PyErr_Occurred()) SWIG_fail;
29961 }
29962 Py_INCREF(Py_None); resultobj = Py_None;
29963 return resultobj;
29964 fail:
29965 return NULL;
29966 }
29967
29968
29969 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29970 PyObject *resultobj;
29971 wxClipboard *arg1 = (wxClipboard *) 0 ;
29972 bool result;
29973 PyObject * obj0 = 0 ;
29974 char *kwnames[] = {
29975 (char *) "self", NULL
29976 };
29977
29978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29980 if (SWIG_arg_fail(1)) SWIG_fail;
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (bool)(arg1)->Flush();
29984
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 {
29989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29990 }
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj;
29999 wxClipboard *arg1 = (wxClipboard *) 0 ;
30000 bool arg2 = (bool) true ;
30001 PyObject * obj0 = 0 ;
30002 PyObject * obj1 = 0 ;
30003 char *kwnames[] = {
30004 (char *) "self",(char *) "primary", NULL
30005 };
30006
30007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30009 if (SWIG_arg_fail(1)) SWIG_fail;
30010 if (obj1) {
30011 {
30012 arg2 = (bool)(SWIG_As_bool(obj1));
30013 if (SWIG_arg_fail(2)) SWIG_fail;
30014 }
30015 }
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 (arg1)->UsePrimarySelection(arg2);
30019
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 Py_INCREF(Py_None); resultobj = Py_None;
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30031 PyObject *resultobj;
30032 wxClipboard *result;
30033 char *kwnames[] = {
30034 NULL
30035 };
30036
30037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30038 {
30039 PyThreadState* __tstate = wxPyBeginAllowThreads();
30040 result = (wxClipboard *)wxClipboard::Get();
30041
30042 wxPyEndAllowThreads(__tstate);
30043 if (PyErr_Occurred()) SWIG_fail;
30044 }
30045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30046 return resultobj;
30047 fail:
30048 return NULL;
30049 }
30050
30051
30052 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30053 PyObject *obj;
30054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30055 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30056 Py_INCREF(obj);
30057 return Py_BuildValue((char *)"");
30058 }
30059 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30060 PyObject *resultobj;
30061 wxClipboard *arg1 = (wxClipboard *) NULL ;
30062 wxClipboardLocker *result;
30063 PyObject * obj0 = 0 ;
30064 char *kwnames[] = {
30065 (char *) "clipboard", NULL
30066 };
30067
30068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30069 if (obj0) {
30070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30071 if (SWIG_arg_fail(1)) SWIG_fail;
30072 }
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30076
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj;
30089 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30090 PyObject * obj0 = 0 ;
30091 char *kwnames[] = {
30092 (char *) "self", NULL
30093 };
30094
30095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(1)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 delete arg1;
30101
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 Py_INCREF(Py_None); resultobj = Py_None;
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj;
30114 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30115 bool result;
30116 PyObject * obj0 = 0 ;
30117 char *kwnames[] = {
30118 (char *) "self", NULL
30119 };
30120
30121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30123 if (SWIG_arg_fail(1)) SWIG_fail;
30124 {
30125 PyThreadState* __tstate = wxPyBeginAllowThreads();
30126 result = (bool)wxClipboardLocker___nonzero__(arg1);
30127
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 {
30132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30133 }
30134 return resultobj;
30135 fail:
30136 return NULL;
30137 }
30138
30139
30140 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30141 PyObject *obj;
30142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30143 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30144 Py_INCREF(obj);
30145 return Py_BuildValue((char *)"");
30146 }
30147 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30148 PyObject *resultobj;
30149 int arg1 = (int) 0 ;
30150 int arg2 = (int) 0 ;
30151 int arg3 = (int) 0 ;
30152 int arg4 = (int) 0 ;
30153 wxVideoMode *result;
30154 PyObject * obj0 = 0 ;
30155 PyObject * obj1 = 0 ;
30156 PyObject * obj2 = 0 ;
30157 PyObject * obj3 = 0 ;
30158 char *kwnames[] = {
30159 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30160 };
30161
30162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30163 if (obj0) {
30164 {
30165 arg1 = (int)(SWIG_As_int(obj0));
30166 if (SWIG_arg_fail(1)) SWIG_fail;
30167 }
30168 }
30169 if (obj1) {
30170 {
30171 arg2 = (int)(SWIG_As_int(obj1));
30172 if (SWIG_arg_fail(2)) SWIG_fail;
30173 }
30174 }
30175 if (obj2) {
30176 {
30177 arg3 = (int)(SWIG_As_int(obj2));
30178 if (SWIG_arg_fail(3)) SWIG_fail;
30179 }
30180 }
30181 if (obj3) {
30182 {
30183 arg4 = (int)(SWIG_As_int(obj3));
30184 if (SWIG_arg_fail(4)) SWIG_fail;
30185 }
30186 }
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30190
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30202 PyObject *resultobj;
30203 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30204 PyObject * obj0 = 0 ;
30205 char *kwnames[] = {
30206 (char *) "self", NULL
30207 };
30208
30209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30211 if (SWIG_arg_fail(1)) SWIG_fail;
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 delete arg1;
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 Py_INCREF(Py_None); resultobj = Py_None;
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30227 PyObject *resultobj;
30228 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30229 wxVideoMode *arg2 = 0 ;
30230 bool result;
30231 PyObject * obj0 = 0 ;
30232 PyObject * obj1 = 0 ;
30233 char *kwnames[] = {
30234 (char *) "self",(char *) "other", NULL
30235 };
30236
30237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30239 if (SWIG_arg_fail(1)) SWIG_fail;
30240 {
30241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30242 if (SWIG_arg_fail(2)) SWIG_fail;
30243 if (arg2 == NULL) {
30244 SWIG_null_ref("wxVideoMode");
30245 }
30246 if (SWIG_arg_fail(2)) SWIG_fail;
30247 }
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30251
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 {
30256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30257 }
30258 return resultobj;
30259 fail:
30260 return NULL;
30261 }
30262
30263
30264 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30265 PyObject *resultobj;
30266 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30267 int result;
30268 PyObject * obj0 = 0 ;
30269 char *kwnames[] = {
30270 (char *) "self", NULL
30271 };
30272
30273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30275 if (SWIG_arg_fail(1)) SWIG_fail;
30276 {
30277 PyThreadState* __tstate = wxPyBeginAllowThreads();
30278 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30279
30280 wxPyEndAllowThreads(__tstate);
30281 if (PyErr_Occurred()) SWIG_fail;
30282 }
30283 {
30284 resultobj = SWIG_From_int((int)(result));
30285 }
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30293 PyObject *resultobj;
30294 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30295 int result;
30296 PyObject * obj0 = 0 ;
30297 char *kwnames[] = {
30298 (char *) "self", NULL
30299 };
30300
30301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30303 if (SWIG_arg_fail(1)) SWIG_fail;
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 {
30312 resultobj = SWIG_From_int((int)(result));
30313 }
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj;
30322 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30323 int result;
30324 PyObject * obj0 = 0 ;
30325 char *kwnames[] = {
30326 (char *) "self", NULL
30327 };
30328
30329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30331 if (SWIG_arg_fail(1)) SWIG_fail;
30332 {
30333 PyThreadState* __tstate = wxPyBeginAllowThreads();
30334 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30335
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 {
30340 resultobj = SWIG_From_int((int)(result));
30341 }
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj;
30350 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30351 bool result;
30352 PyObject * obj0 = 0 ;
30353 char *kwnames[] = {
30354 (char *) "self", NULL
30355 };
30356
30357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30359 if (SWIG_arg_fail(1)) SWIG_fail;
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30363
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 {
30368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30369 }
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30377 PyObject *resultobj;
30378 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30379 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30380 bool result;
30381 PyObject * obj0 = 0 ;
30382 PyObject * obj1 = 0 ;
30383 char *kwnames[] = {
30384 (char *) "self",(char *) "other", NULL
30385 };
30386
30387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30389 if (SWIG_arg_fail(1)) SWIG_fail;
30390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30391 if (SWIG_arg_fail(2)) SWIG_fail;
30392 {
30393 PyThreadState* __tstate = wxPyBeginAllowThreads();
30394 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30395
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 {
30400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30401 }
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30409 PyObject *resultobj;
30410 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30411 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30412 bool result;
30413 PyObject * obj0 = 0 ;
30414 PyObject * obj1 = 0 ;
30415 char *kwnames[] = {
30416 (char *) "self",(char *) "other", NULL
30417 };
30418
30419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30421 if (SWIG_arg_fail(1)) SWIG_fail;
30422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30423 if (SWIG_arg_fail(2)) SWIG_fail;
30424 {
30425 PyThreadState* __tstate = wxPyBeginAllowThreads();
30426 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30427
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 {
30432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30433 }
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj;
30442 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30443 int arg2 ;
30444 PyObject * obj0 = 0 ;
30445 PyObject * obj1 = 0 ;
30446 char *kwnames[] = {
30447 (char *) "self",(char *) "w", NULL
30448 };
30449
30450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30452 if (SWIG_arg_fail(1)) SWIG_fail;
30453 {
30454 arg2 = (int)(SWIG_As_int(obj1));
30455 if (SWIG_arg_fail(2)) SWIG_fail;
30456 }
30457 if (arg1) (arg1)->w = arg2;
30458
30459 Py_INCREF(Py_None); resultobj = Py_None;
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30467 PyObject *resultobj;
30468 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30469 int result;
30470 PyObject * obj0 = 0 ;
30471 char *kwnames[] = {
30472 (char *) "self", NULL
30473 };
30474
30475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30477 if (SWIG_arg_fail(1)) SWIG_fail;
30478 result = (int) ((arg1)->w);
30479
30480 {
30481 resultobj = SWIG_From_int((int)(result));
30482 }
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj;
30491 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30492 int arg2 ;
30493 PyObject * obj0 = 0 ;
30494 PyObject * obj1 = 0 ;
30495 char *kwnames[] = {
30496 (char *) "self",(char *) "h", NULL
30497 };
30498
30499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30501 if (SWIG_arg_fail(1)) SWIG_fail;
30502 {
30503 arg2 = (int)(SWIG_As_int(obj1));
30504 if (SWIG_arg_fail(2)) SWIG_fail;
30505 }
30506 if (arg1) (arg1)->h = arg2;
30507
30508 Py_INCREF(Py_None); resultobj = Py_None;
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30516 PyObject *resultobj;
30517 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30518 int result;
30519 PyObject * obj0 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 result = (int) ((arg1)->h);
30528
30529 {
30530 resultobj = SWIG_From_int((int)(result));
30531 }
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30539 PyObject *resultobj;
30540 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30541 int arg2 ;
30542 PyObject * obj0 = 0 ;
30543 PyObject * obj1 = 0 ;
30544 char *kwnames[] = {
30545 (char *) "self",(char *) "bpp", NULL
30546 };
30547
30548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30550 if (SWIG_arg_fail(1)) SWIG_fail;
30551 {
30552 arg2 = (int)(SWIG_As_int(obj1));
30553 if (SWIG_arg_fail(2)) SWIG_fail;
30554 }
30555 if (arg1) (arg1)->bpp = arg2;
30556
30557 Py_INCREF(Py_None); resultobj = Py_None;
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30565 PyObject *resultobj;
30566 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30567 int result;
30568 PyObject * obj0 = 0 ;
30569 char *kwnames[] = {
30570 (char *) "self", NULL
30571 };
30572
30573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30575 if (SWIG_arg_fail(1)) SWIG_fail;
30576 result = (int) ((arg1)->bpp);
30577
30578 {
30579 resultobj = SWIG_From_int((int)(result));
30580 }
30581 return resultobj;
30582 fail:
30583 return NULL;
30584 }
30585
30586
30587 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30588 PyObject *resultobj;
30589 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30590 int arg2 ;
30591 PyObject * obj0 = 0 ;
30592 PyObject * obj1 = 0 ;
30593 char *kwnames[] = {
30594 (char *) "self",(char *) "refresh", NULL
30595 };
30596
30597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30599 if (SWIG_arg_fail(1)) SWIG_fail;
30600 {
30601 arg2 = (int)(SWIG_As_int(obj1));
30602 if (SWIG_arg_fail(2)) SWIG_fail;
30603 }
30604 if (arg1) (arg1)->refresh = arg2;
30605
30606 Py_INCREF(Py_None); resultobj = Py_None;
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30614 PyObject *resultobj;
30615 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30616 int result;
30617 PyObject * obj0 = 0 ;
30618 char *kwnames[] = {
30619 (char *) "self", NULL
30620 };
30621
30622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30624 if (SWIG_arg_fail(1)) SWIG_fail;
30625 result = (int) ((arg1)->refresh);
30626
30627 {
30628 resultobj = SWIG_From_int((int)(result));
30629 }
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30637 PyObject *obj;
30638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30639 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30640 Py_INCREF(obj);
30641 return Py_BuildValue((char *)"");
30642 }
30643 static int _wrap_DefaultVideoMode_set(PyObject *) {
30644 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30645 return 1;
30646 }
30647
30648
30649 static PyObject *_wrap_DefaultVideoMode_get(void) {
30650 PyObject *pyobj;
30651
30652 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30653 return pyobj;
30654 }
30655
30656
30657 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj;
30659 size_t arg1 = (size_t) 0 ;
30660 wxDisplay *result;
30661 PyObject * obj0 = 0 ;
30662 char *kwnames[] = {
30663 (char *) "index", NULL
30664 };
30665
30666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30667 if (obj0) {
30668 {
30669 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30670 if (SWIG_arg_fail(1)) SWIG_fail;
30671 }
30672 }
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 result = (wxDisplay *)new wxDisplay(arg1);
30676
30677 wxPyEndAllowThreads(__tstate);
30678 if (PyErr_Occurred()) SWIG_fail;
30679 }
30680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30681 return resultobj;
30682 fail:
30683 return NULL;
30684 }
30685
30686
30687 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30688 PyObject *resultobj;
30689 wxDisplay *arg1 = (wxDisplay *) 0 ;
30690 PyObject * obj0 = 0 ;
30691 char *kwnames[] = {
30692 (char *) "self", NULL
30693 };
30694
30695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30697 if (SWIG_arg_fail(1)) SWIG_fail;
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 delete arg1;
30701
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 Py_INCREF(Py_None); resultobj = Py_None;
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30713 PyObject *resultobj;
30714 size_t result;
30715 char *kwnames[] = {
30716 NULL
30717 };
30718
30719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (size_t)wxDisplay::GetCount();
30723
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30737 PyObject *resultobj;
30738 wxPoint *arg1 = 0 ;
30739 int result;
30740 wxPoint temp1 ;
30741 PyObject * obj0 = 0 ;
30742 char *kwnames[] = {
30743 (char *) "pt", NULL
30744 };
30745
30746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30747 {
30748 arg1 = &temp1;
30749 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30750 }
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30754
30755 wxPyEndAllowThreads(__tstate);
30756 if (PyErr_Occurred()) SWIG_fail;
30757 }
30758 {
30759 resultobj = SWIG_From_int((int)(result));
30760 }
30761 return resultobj;
30762 fail:
30763 return NULL;
30764 }
30765
30766
30767 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30768 PyObject *resultobj;
30769 wxWindow *arg1 = (wxWindow *) 0 ;
30770 int result;
30771 PyObject * obj0 = 0 ;
30772 char *kwnames[] = {
30773 (char *) "window", NULL
30774 };
30775
30776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30778 if (SWIG_arg_fail(1)) SWIG_fail;
30779 {
30780 PyThreadState* __tstate = wxPyBeginAllowThreads();
30781 result = (int)Display_GetFromWindow(arg1);
30782
30783 wxPyEndAllowThreads(__tstate);
30784 if (PyErr_Occurred()) SWIG_fail;
30785 }
30786 {
30787 resultobj = SWIG_From_int((int)(result));
30788 }
30789 return resultobj;
30790 fail:
30791 return NULL;
30792 }
30793
30794
30795 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30796 PyObject *resultobj;
30797 wxDisplay *arg1 = (wxDisplay *) 0 ;
30798 bool result;
30799 PyObject * obj0 = 0 ;
30800 char *kwnames[] = {
30801 (char *) "self", NULL
30802 };
30803
30804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30806 if (SWIG_arg_fail(1)) SWIG_fail;
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = (bool)((wxDisplay const *)arg1)->IsOk();
30810
30811 wxPyEndAllowThreads(__tstate);
30812 if (PyErr_Occurred()) SWIG_fail;
30813 }
30814 {
30815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30816 }
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30824 PyObject *resultobj;
30825 wxDisplay *arg1 = (wxDisplay *) 0 ;
30826 wxRect result;
30827 PyObject * obj0 = 0 ;
30828 char *kwnames[] = {
30829 (char *) "self", NULL
30830 };
30831
30832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(1)) SWIG_fail;
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = ((wxDisplay const *)arg1)->GetGeometry();
30838
30839 wxPyEndAllowThreads(__tstate);
30840 if (PyErr_Occurred()) SWIG_fail;
30841 }
30842 {
30843 wxRect * resultptr;
30844 resultptr = new wxRect((wxRect &)(result));
30845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30854 PyObject *resultobj;
30855 wxDisplay *arg1 = (wxDisplay *) 0 ;
30856 wxString result;
30857 PyObject * obj0 = 0 ;
30858 char *kwnames[] = {
30859 (char *) "self", NULL
30860 };
30861
30862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30864 if (SWIG_arg_fail(1)) SWIG_fail;
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = ((wxDisplay const *)arg1)->GetName();
30868
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 {
30873 #if wxUSE_UNICODE
30874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30875 #else
30876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30877 #endif
30878 }
30879 return resultobj;
30880 fail:
30881 return NULL;
30882 }
30883
30884
30885 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30886 PyObject *resultobj;
30887 wxDisplay *arg1 = (wxDisplay *) 0 ;
30888 bool result;
30889 PyObject * obj0 = 0 ;
30890 char *kwnames[] = {
30891 (char *) "self", NULL
30892 };
30893
30894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30896 if (SWIG_arg_fail(1)) SWIG_fail;
30897 {
30898 PyThreadState* __tstate = wxPyBeginAllowThreads();
30899 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30900
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 {
30905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30906 }
30907 return resultobj;
30908 fail:
30909 return NULL;
30910 }
30911
30912
30913 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30914 PyObject *resultobj;
30915 wxDisplay *arg1 = (wxDisplay *) 0 ;
30916 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30917 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30918 PyObject *result;
30919 PyObject * obj0 = 0 ;
30920 PyObject * obj1 = 0 ;
30921 char *kwnames[] = {
30922 (char *) "self",(char *) "mode", NULL
30923 };
30924
30925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30927 if (SWIG_arg_fail(1)) SWIG_fail;
30928 if (obj1) {
30929 {
30930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30931 if (SWIG_arg_fail(2)) SWIG_fail;
30932 if (arg2 == NULL) {
30933 SWIG_null_ref("wxVideoMode");
30934 }
30935 if (SWIG_arg_fail(2)) SWIG_fail;
30936 }
30937 }
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30941
30942 wxPyEndAllowThreads(__tstate);
30943 if (PyErr_Occurred()) SWIG_fail;
30944 }
30945 resultobj = result;
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj;
30954 wxDisplay *arg1 = (wxDisplay *) 0 ;
30955 wxVideoMode result;
30956 PyObject * obj0 = 0 ;
30957 char *kwnames[] = {
30958 (char *) "self", NULL
30959 };
30960
30961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30963 if (SWIG_arg_fail(1)) SWIG_fail;
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30967
30968 wxPyEndAllowThreads(__tstate);
30969 if (PyErr_Occurred()) SWIG_fail;
30970 }
30971 {
30972 wxVideoMode * resultptr;
30973 resultptr = new wxVideoMode((wxVideoMode &)(result));
30974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30975 }
30976 return resultobj;
30977 fail:
30978 return NULL;
30979 }
30980
30981
30982 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30983 PyObject *resultobj;
30984 wxDisplay *arg1 = (wxDisplay *) 0 ;
30985 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30986 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30987 bool result;
30988 PyObject * obj0 = 0 ;
30989 PyObject * obj1 = 0 ;
30990 char *kwnames[] = {
30991 (char *) "self",(char *) "mode", NULL
30992 };
30993
30994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30996 if (SWIG_arg_fail(1)) SWIG_fail;
30997 if (obj1) {
30998 {
30999 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31000 if (SWIG_arg_fail(2)) SWIG_fail;
31001 if (arg2 == NULL) {
31002 SWIG_null_ref("wxVideoMode");
31003 }
31004 if (SWIG_arg_fail(2)) SWIG_fail;
31005 }
31006 }
31007 {
31008 PyThreadState* __tstate = wxPyBeginAllowThreads();
31009 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31010
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 {
31015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31016 }
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj;
31025 wxDisplay *arg1 = (wxDisplay *) 0 ;
31026 PyObject * obj0 = 0 ;
31027 char *kwnames[] = {
31028 (char *) "self", NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31033 if (SWIG_arg_fail(1)) SWIG_fail;
31034 {
31035 PyThreadState* __tstate = wxPyBeginAllowThreads();
31036 (arg1)->ResetMode();
31037
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 Py_INCREF(Py_None); resultobj = Py_None;
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31049 PyObject *obj;
31050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31051 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31052 Py_INCREF(obj);
31053 return Py_BuildValue((char *)"");
31054 }
31055 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31056 PyObject *resultobj;
31057 wxStandardPaths *result;
31058 char *kwnames[] = {
31059 NULL
31060 };
31061
31062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 result = (wxStandardPaths *)StandardPaths_Get();
31066
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31071 return resultobj;
31072 fail:
31073 return NULL;
31074 }
31075
31076
31077 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31078 PyObject *resultobj;
31079 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31080 wxString result;
31081 PyObject * obj0 = 0 ;
31082 char *kwnames[] = {
31083 (char *) "self", NULL
31084 };
31085
31086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31088 if (SWIG_arg_fail(1)) SWIG_fail;
31089 {
31090 PyThreadState* __tstate = wxPyBeginAllowThreads();
31091 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31092
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 {
31097 #if wxUSE_UNICODE
31098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31099 #else
31100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31101 #endif
31102 }
31103 return resultobj;
31104 fail:
31105 return NULL;
31106 }
31107
31108
31109 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31110 PyObject *resultobj;
31111 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31112 wxString result;
31113 PyObject * obj0 = 0 ;
31114 char *kwnames[] = {
31115 (char *) "self", NULL
31116 };
31117
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31120 if (SWIG_arg_fail(1)) SWIG_fail;
31121 {
31122 PyThreadState* __tstate = wxPyBeginAllowThreads();
31123 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31124
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 {
31129 #if wxUSE_UNICODE
31130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31131 #else
31132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31133 #endif
31134 }
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj;
31143 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31144 wxString result;
31145 PyObject * obj0 = 0 ;
31146 char *kwnames[] = {
31147 (char *) "self", NULL
31148 };
31149
31150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31152 if (SWIG_arg_fail(1)) SWIG_fail;
31153 {
31154 PyThreadState* __tstate = wxPyBeginAllowThreads();
31155 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31156
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 {
31161 #if wxUSE_UNICODE
31162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31163 #else
31164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31165 #endif
31166 }
31167 return resultobj;
31168 fail:
31169 return NULL;
31170 }
31171
31172
31173 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31174 PyObject *resultobj;
31175 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31176 wxString result;
31177 PyObject * obj0 = 0 ;
31178 char *kwnames[] = {
31179 (char *) "self", NULL
31180 };
31181
31182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31184 if (SWIG_arg_fail(1)) SWIG_fail;
31185 {
31186 PyThreadState* __tstate = wxPyBeginAllowThreads();
31187 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31188
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 {
31193 #if wxUSE_UNICODE
31194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31195 #else
31196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31197 #endif
31198 }
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31206 PyObject *resultobj;
31207 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31208 wxString result;
31209 PyObject * obj0 = 0 ;
31210 char *kwnames[] = {
31211 (char *) "self", NULL
31212 };
31213
31214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31216 if (SWIG_arg_fail(1)) SWIG_fail;
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31220
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 {
31225 #if wxUSE_UNICODE
31226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31227 #else
31228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31229 #endif
31230 }
31231 return resultobj;
31232 fail:
31233 return NULL;
31234 }
31235
31236
31237 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31238 PyObject *resultobj;
31239 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31240 wxString result;
31241 PyObject * obj0 = 0 ;
31242 char *kwnames[] = {
31243 (char *) "self", NULL
31244 };
31245
31246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31248 if (SWIG_arg_fail(1)) SWIG_fail;
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31252
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 {
31257 #if wxUSE_UNICODE
31258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31259 #else
31260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31261 #endif
31262 }
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31270 PyObject *resultobj;
31271 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31272 wxString result;
31273 PyObject * obj0 = 0 ;
31274 char *kwnames[] = {
31275 (char *) "self", NULL
31276 };
31277
31278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31280 if (SWIG_arg_fail(1)) SWIG_fail;
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31284
31285 wxPyEndAllowThreads(__tstate);
31286 if (PyErr_Occurred()) SWIG_fail;
31287 }
31288 {
31289 #if wxUSE_UNICODE
31290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31291 #else
31292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31293 #endif
31294 }
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31302 PyObject *resultobj;
31303 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31304 wxString *arg2 = 0 ;
31305 bool temp2 = false ;
31306 PyObject * obj0 = 0 ;
31307 PyObject * obj1 = 0 ;
31308 char *kwnames[] = {
31309 (char *) "self",(char *) "prefix", NULL
31310 };
31311
31312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31314 if (SWIG_arg_fail(1)) SWIG_fail;
31315 {
31316 arg2 = wxString_in_helper(obj1);
31317 if (arg2 == NULL) SWIG_fail;
31318 temp2 = true;
31319 }
31320 {
31321 PyThreadState* __tstate = wxPyBeginAllowThreads();
31322 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31323
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 Py_INCREF(Py_None); resultobj = Py_None;
31328 {
31329 if (temp2)
31330 delete arg2;
31331 }
31332 return resultobj;
31333 fail:
31334 {
31335 if (temp2)
31336 delete arg2;
31337 }
31338 return NULL;
31339 }
31340
31341
31342 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31343 PyObject *resultobj;
31344 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31345 wxString result;
31346 PyObject * obj0 = 0 ;
31347 char *kwnames[] = {
31348 (char *) "self", NULL
31349 };
31350
31351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31353 if (SWIG_arg_fail(1)) SWIG_fail;
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = wxStandardPaths_GetInstallPrefix(arg1);
31357
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 {
31362 #if wxUSE_UNICODE
31363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31364 #else
31365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31366 #endif
31367 }
31368 return resultobj;
31369 fail:
31370 return NULL;
31371 }
31372
31373
31374 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31375 PyObject *obj;
31376 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31377 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31378 Py_INCREF(obj);
31379 return Py_BuildValue((char *)"");
31380 }
31381 static PyMethodDef SwigMethods[] = {
31382 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31389 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31396 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31460 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31468 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31486 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31489 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31492 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31495 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31501 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31515 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31521 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31527 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31530 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31544 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31547 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31548 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31551 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31578 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31580 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31582 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31584 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31591 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31597 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31611 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31615 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31618 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31635 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31643 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31690 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31708 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31718 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31734 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31750 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31764 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"ArtProvider_GetSize", (PyCFunction) _wrap_ArtProvider_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31774 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31817 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31820 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31823 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31827 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31920 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31921 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31922 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31923 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31940 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31985 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32019 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32027 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32028 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32033 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32042 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32049 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32052 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32055 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32060 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32063 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32067 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32070 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32074 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32075 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32079 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32083 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32087 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32097 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32108 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32116 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32124 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32138 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32142 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32160 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32174 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32185 { NULL, NULL, 0, NULL }
32186 };
32187
32188
32189 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32190
32191 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32192 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32193 }
32194 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32195 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32196 }
32197 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32198 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32199 }
32200 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32201 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32202 }
32203 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32204 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32205 }
32206 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32207 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32208 }
32209 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32210 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32211 }
32212 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32213 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32214 }
32215 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32216 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32217 }
32218 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32219 return (void *)((wxEvent *) ((wxPyEvent *) x));
32220 }
32221 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32223 }
32224 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32225 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32226 }
32227 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32228 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32229 }
32230 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32231 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32232 }
32233 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32234 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32235 }
32236 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32237 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32238 }
32239 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32240 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32241 }
32242 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32243 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32244 }
32245 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32246 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32247 }
32248 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32249 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32250 }
32251 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32253 }
32254 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32255 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32256 }
32257 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32258 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32259 }
32260 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32261 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32262 }
32263 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32264 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32265 }
32266 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32267 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32268 }
32269 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32270 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32271 }
32272 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32273 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32274 }
32275 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32276 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32277 }
32278 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32279 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32280 }
32281 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32283 }
32284 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32285 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32286 }
32287 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32288 return (void *)((wxEvent *) ((wxShowEvent *) x));
32289 }
32290 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32291 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32292 }
32293 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32294 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32295 }
32296 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32298 }
32299 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32300 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32301 }
32302 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32303 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32304 }
32305 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32306 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32307 }
32308 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32309 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32310 }
32311 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32312 return (void *)((wxConfigBase *) ((wxConfig *) x));
32313 }
32314 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32315 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32316 }
32317 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32318 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32319 }
32320 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32321 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32322 }
32323 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32324 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32325 }
32326 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32327 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32328 }
32329 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32330 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32331 }
32332 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32333 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32334 }
32335 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32336 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32337 }
32338 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32339 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32340 }
32341 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32342 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32343 }
32344 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32345 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32346 }
32347 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32348 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32349 }
32350 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32351 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32352 }
32353 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32354 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32355 }
32356 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32357 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32358 }
32359 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32360 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32361 }
32362 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32363 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32364 }
32365 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32366 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32367 }
32368 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32369 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32370 }
32371 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32372 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32373 }
32374 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32375 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32376 }
32377 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32378 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32379 }
32380 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32381 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32382 }
32383 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32384 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32385 }
32386 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32387 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32388 }
32389 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32390 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32391 }
32392 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32393 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32394 }
32395 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32396 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32397 }
32398 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32399 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32400 }
32401 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32402 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32403 }
32404 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32405 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32406 }
32407 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32408 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32409 }
32410 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32411 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32412 }
32413 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32414 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32415 }
32416 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32417 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32418 }
32419 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32420 return (void *)((wxObject *) ((wxSizerItem *) x));
32421 }
32422 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32423 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32424 }
32425 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32426 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32427 }
32428 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32429 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32430 }
32431 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32432 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32433 }
32434 static void *_p_wxSizerTo_p_wxObject(void *x) {
32435 return (void *)((wxObject *) ((wxSizer *) x));
32436 }
32437 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32438 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32439 }
32440 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32441 return (void *)((wxObject *) ((wxFileHistory *) x));
32442 }
32443 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32445 }
32446 static void *_p_wxEventTo_p_wxObject(void *x) {
32447 return (void *)((wxObject *) ((wxEvent *) x));
32448 }
32449 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32450 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32451 }
32452 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32453 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32454 }
32455 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32456 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32457 }
32458 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32459 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32460 }
32461 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32463 }
32464 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32466 }
32467 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32469 }
32470 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32472 }
32473 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32475 }
32476 static void *_p_wxControlTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32478 }
32479 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32481 }
32482 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32484 }
32485 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) ((wxFSFile *) x));
32487 }
32488 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) ((wxClipboard *) x));
32490 }
32491 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32493 }
32494 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32496 }
32497 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32499 }
32500 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32502 }
32503 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) ((wxToolTip *) x));
32505 }
32506 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) ((wxMenuItem *) x));
32508 }
32509 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32511 }
32512 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32514 }
32515 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32517 }
32518 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32520 }
32521 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32523 }
32524 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32526 }
32527 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32529 }
32530 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32532 }
32533 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32535 }
32536 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32538 }
32539 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32541 }
32542 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32544 }
32545 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32547 }
32548 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32550 }
32551 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32553 }
32554 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32556 }
32557 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32559 }
32560 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32562 }
32563 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32565 }
32566 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) ((wxImageHandler *) x));
32568 }
32569 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32571 }
32572 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) ((wxEvtHandler *) x));
32574 }
32575 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32577 }
32578 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32580 }
32581 static void *_p_wxImageTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) ((wxImage *) x));
32583 }
32584 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32586 }
32587 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) ((wxSystemOptions *) x));
32589 }
32590 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32592 }
32593 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32595 }
32596 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32598 }
32599 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32601 }
32602 static void *_p_wxWindowTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32604 }
32605 static void *_p_wxMenuTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32607 }
32608 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32610 }
32611 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32613 }
32614 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) ((wxFileSystem *) x));
32616 }
32617 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32619 }
32620 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32622 }
32623 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32625 }
32626 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32628 }
32629 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32631 }
32632 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32634 }
32635 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) ((wxBusyInfo *) x));
32637 }
32638 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32640 }
32641 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32643 }
32644 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32646 }
32647 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32649 }
32650 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32652 }
32653 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32655 }
32656 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32658 }
32659 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32661 }
32662 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32664 }
32665 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32667 }
32668 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32669 return (void *)((wxLog *) ((wxLogStderr *) x));
32670 }
32671 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32672 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32673 }
32674 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32675 return (void *)((wxLog *) ((wxLogWindow *) x));
32676 }
32677 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32678 return (void *)((wxLog *) ((wxLogChain *) x));
32679 }
32680 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32681 return (void *)((wxLog *) ((wxLogGui *) x));
32682 }
32683 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32684 return (void *)((wxLog *) ((wxPyLog *) x));
32685 }
32686 static void *_p_wxControlTo_p_wxWindow(void *x) {
32687 return (void *)((wxWindow *) ((wxControl *) x));
32688 }
32689 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32690 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32691 }
32692 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32693 return (void *)((wxWindow *) ((wxMenuBar *) x));
32694 }
32695 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32696 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32697 }
32698 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32699 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32700 }
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogStderr", _p_wxLogStderrTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogTextCtrl", _p_wxLogTextCtrlTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogWindow", _p_wxLogWindowTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogChain", _p_wxLogChainTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogGui", _p_wxLogGuiTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxPyLog", _p_wxPyLogTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746 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}};
32747 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}};
32748 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}};
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766 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}};
32767 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}};
32768 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}};
32769 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}};
32770 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}};
32771 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}};
32772 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}};
32773 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}};
32774 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}};
32775 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}};
32776 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}};
32777 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}};
32778 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}};
32779 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}};
32780 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}};
32781 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}};
32782 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}};
32783 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}};
32784 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}};
32785 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}};
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798
32799 static swig_type_info *swig_types_initial[] = {
32800 _swigt__p_wxLogChain,
32801 _swigt__p_wxMutexGuiLocker,
32802 _swigt__p_wxMetafile,
32803 _swigt__p_wxFileHistory,
32804 _swigt__p_wxLog,
32805 _swigt__p_wxMenu,
32806 _swigt__p_wxEvent,
32807 _swigt__p_wxDateTime__TimeZone,
32808 _swigt__p_wxConfigBase,
32809 _swigt__p_wxDisplay,
32810 _swigt__p_wxFileType,
32811 _swigt__p_wxLogGui,
32812 _swigt__p_wxFont,
32813 _swigt__p_wxDataFormat,
32814 _swigt__p_wxTimerEvent,
32815 _swigt__p_wxCaret,
32816 _swigt__ptrdiff_t,
32817 _swigt__std__ptrdiff_t,
32818 _swigt__p_int,
32819 _swigt__p_wxSize,
32820 _swigt__p_wxClipboard,
32821 _swigt__p_wxStopWatch,
32822 _swigt__p_wxDC,
32823 _swigt__p_wxClipboardLocker,
32824 _swigt__p_wxIcon,
32825 _swigt__p_wxLogStderr,
32826 _swigt__p_wxLogTextCtrl,
32827 _swigt__p_wxTextCtrl,
32828 _swigt__p_wxBusyCursor,
32829 _swigt__p_wxBitmapDataObject,
32830 _swigt__p_wxTextDataObject,
32831 _swigt__p_wxDataObject,
32832 _swigt__p_wxPyTextDataObject,
32833 _swigt__p_wxPyBitmapDataObject,
32834 _swigt__p_wxFileDataObject,
32835 _swigt__p_wxCustomDataObject,
32836 _swigt__p_wxURLDataObject,
32837 _swigt__p_wxMetafileDataObject,
32838 _swigt__p_wxSound,
32839 _swigt__p_wxTimerRunner,
32840 _swigt__p_wxLogWindow,
32841 _swigt__p_wxTimeSpan,
32842 _swigt__p_wxArrayString,
32843 _swigt__p_wxWindowDisabler,
32844 _swigt__p_form_ops_t,
32845 _swigt__p_wxToolTip,
32846 _swigt__p_wxDataObjectComposite,
32847 _swigt__p_wxSystemSettings,
32848 _swigt__p_wxFileConfig,
32849 _swigt__p_wxVideoMode,
32850 _swigt__p_wxDataObjectSimple,
32851 _swigt__p_wxPyDataObjectSimple,
32852 _swigt__p_wxDuplexMode,
32853 _swigt__p_wxEvtHandler,
32854 _swigt__p_wxRect,
32855 _swigt__p_char,
32856 _swigt__p_wxSingleInstanceChecker,
32857 _swigt__p_wxStandardPaths,
32858 _swigt__p_wxFileTypeInfo,
32859 _swigt__p_wxFrame,
32860 _swigt__p_wxTimer,
32861 _swigt__p_wxPaperSize,
32862 _swigt__p_wxMimeTypesManager,
32863 _swigt__p_wxPyArtProvider,
32864 _swigt__p_wxPyTipProvider,
32865 _swigt__p_wxTipProvider,
32866 _swigt__p_wxJoystick,
32867 _swigt__p_wxSystemOptions,
32868 _swigt__p_wxPoint,
32869 _swigt__p_wxJoystickEvent,
32870 _swigt__p_wxCursor,
32871 _swigt__p_wxObject,
32872 _swigt__p_wxOutputStream,
32873 _swigt__p_wxDateTime,
32874 _swigt__p_wxPyDropSource,
32875 _swigt__p_unsigned_long,
32876 _swigt__p_wxKillError,
32877 _swigt__p_wxWindow,
32878 _swigt__p_wxString,
32879 _swigt__p_wxPyProcess,
32880 _swigt__p_wxBitmap,
32881 _swigt__p_wxConfig,
32882 _swigt__unsigned_int,
32883 _swigt__p_unsigned_int,
32884 _swigt__p_unsigned_char,
32885 _swigt__p_wxChar,
32886 _swigt__p_wxBusyInfo,
32887 _swigt__p_wxPyDropTarget,
32888 _swigt__p_wxPyTextDropTarget,
32889 _swigt__p_wxPyFileDropTarget,
32890 _swigt__p_wxProcessEvent,
32891 _swigt__p_wxPyLog,
32892 _swigt__p_wxLogNull,
32893 _swigt__p_wxColour,
32894 _swigt__p_wxPyTimer,
32895 _swigt__p_wxConfigPathChanger,
32896 _swigt__p_wxDateSpan,
32897 0
32898 };
32899
32900
32901 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32902
32903 static swig_const_info swig_const_table[] = {
32904 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32905 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32906 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32907 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32908 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32909 {0, 0, 0, 0.0, 0, 0}};
32910
32911 #ifdef __cplusplus
32912 }
32913 #endif
32914
32915
32916 #ifdef __cplusplus
32917 extern "C" {
32918 #endif
32919
32920 /* Python-specific SWIG API */
32921 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32922 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32923 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32924
32925 /* -----------------------------------------------------------------------------
32926 * global variable support code.
32927 * ----------------------------------------------------------------------------- */
32928
32929 typedef struct swig_globalvar {
32930 char *name; /* Name of global variable */
32931 PyObject *(*get_attr)(); /* Return the current value */
32932 int (*set_attr)(PyObject *); /* Set the value */
32933 struct swig_globalvar *next;
32934 } swig_globalvar;
32935
32936 typedef struct swig_varlinkobject {
32937 PyObject_HEAD
32938 swig_globalvar *vars;
32939 } swig_varlinkobject;
32940
32941 static PyObject *
32942 swig_varlink_repr(swig_varlinkobject *v) {
32943 v = v;
32944 return PyString_FromString("<Swig global variables>");
32945 }
32946
32947 static int
32948 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32949 swig_globalvar *var;
32950 flags = flags;
32951 fprintf(fp,"Swig global variables { ");
32952 for (var = v->vars; var; var=var->next) {
32953 fprintf(fp,"%s", var->name);
32954 if (var->next) fprintf(fp,", ");
32955 }
32956 fprintf(fp," }\n");
32957 return 0;
32958 }
32959
32960 static PyObject *
32961 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32962 swig_globalvar *var = v->vars;
32963 while (var) {
32964 if (strcmp(var->name,n) == 0) {
32965 return (*var->get_attr)();
32966 }
32967 var = var->next;
32968 }
32969 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32970 return NULL;
32971 }
32972
32973 static int
32974 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32975 swig_globalvar *var = v->vars;
32976 while (var) {
32977 if (strcmp(var->name,n) == 0) {
32978 return (*var->set_attr)(p);
32979 }
32980 var = var->next;
32981 }
32982 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32983 return 1;
32984 }
32985
32986 static PyTypeObject varlinktype = {
32987 PyObject_HEAD_INIT(0)
32988 0, /* Number of items in variable part (ob_size) */
32989 (char *)"swigvarlink", /* Type name (tp_name) */
32990 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32991 0, /* Itemsize (tp_itemsize) */
32992 0, /* Deallocator (tp_dealloc) */
32993 (printfunc) swig_varlink_print, /* Print (tp_print) */
32994 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32995 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32996 0, /* tp_compare */
32997 (reprfunc) swig_varlink_repr, /* tp_repr */
32998 0, /* tp_as_number */
32999 0, /* tp_as_sequence */
33000 0, /* tp_as_mapping */
33001 0, /* tp_hash */
33002 0, /* tp_call */
33003 0, /* tp_str */
33004 0, /* tp_getattro */
33005 0, /* tp_setattro */
33006 0, /* tp_as_buffer */
33007 0, /* tp_flags */
33008 0, /* tp_doc */
33009 #if PY_VERSION_HEX >= 0x02000000
33010 0, /* tp_traverse */
33011 0, /* tp_clear */
33012 #endif
33013 #if PY_VERSION_HEX >= 0x02010000
33014 0, /* tp_richcompare */
33015 0, /* tp_weaklistoffset */
33016 #endif
33017 #if PY_VERSION_HEX >= 0x02020000
33018 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33019 #endif
33020 #if PY_VERSION_HEX >= 0x02030000
33021 0, /* tp_del */
33022 #endif
33023 #ifdef COUNT_ALLOCS
33024 0,0,0,0 /* tp_alloc -> tp_next */
33025 #endif
33026 };
33027
33028 /* Create a variable linking object for use later */
33029 static PyObject *
33030 SWIG_Python_newvarlink(void) {
33031 swig_varlinkobject *result = 0;
33032 result = PyMem_NEW(swig_varlinkobject,1);
33033 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33034 result->ob_type = &varlinktype;
33035 result->vars = 0;
33036 result->ob_refcnt = 0;
33037 Py_XINCREF((PyObject *) result);
33038 return ((PyObject*) result);
33039 }
33040
33041 static void
33042 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33043 swig_varlinkobject *v;
33044 swig_globalvar *gv;
33045 v= (swig_varlinkobject *) p;
33046 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33047 gv->name = (char *) malloc(strlen(name)+1);
33048 strcpy(gv->name,name);
33049 gv->get_attr = get_attr;
33050 gv->set_attr = set_attr;
33051 gv->next = v->vars;
33052 v->vars = gv;
33053 }
33054
33055 /* -----------------------------------------------------------------------------
33056 * constants/methods manipulation
33057 * ----------------------------------------------------------------------------- */
33058
33059 /* Install Constants */
33060 static void
33061 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33062 PyObject *obj = 0;
33063 size_t i;
33064 for (i = 0; constants[i].type; i++) {
33065 switch(constants[i].type) {
33066 case SWIG_PY_INT:
33067 obj = PyInt_FromLong(constants[i].lvalue);
33068 break;
33069 case SWIG_PY_FLOAT:
33070 obj = PyFloat_FromDouble(constants[i].dvalue);
33071 break;
33072 case SWIG_PY_STRING:
33073 if (constants[i].pvalue) {
33074 obj = PyString_FromString((char *) constants[i].pvalue);
33075 } else {
33076 Py_INCREF(Py_None);
33077 obj = Py_None;
33078 }
33079 break;
33080 case SWIG_PY_POINTER:
33081 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33082 break;
33083 case SWIG_PY_BINARY:
33084 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33085 break;
33086 default:
33087 obj = 0;
33088 break;
33089 }
33090 if (obj) {
33091 PyDict_SetItemString(d,constants[i].name,obj);
33092 Py_DECREF(obj);
33093 }
33094 }
33095 }
33096
33097 /* -----------------------------------------------------------------------------*/
33098 /* Fix SwigMethods to carry the callback ptrs when needed */
33099 /* -----------------------------------------------------------------------------*/
33100
33101 static void
33102 SWIG_Python_FixMethods(PyMethodDef *methods,
33103 swig_const_info *const_table,
33104 swig_type_info **types,
33105 swig_type_info **types_initial) {
33106 size_t i;
33107 for (i = 0; methods[i].ml_name; ++i) {
33108 char *c = methods[i].ml_doc;
33109 if (c && (c = strstr(c, "swig_ptr: "))) {
33110 int j;
33111 swig_const_info *ci = 0;
33112 char *name = c + 10;
33113 for (j = 0; const_table[j].type; j++) {
33114 if (strncmp(const_table[j].name, name,
33115 strlen(const_table[j].name)) == 0) {
33116 ci = &(const_table[j]);
33117 break;
33118 }
33119 }
33120 if (ci) {
33121 size_t shift = (ci->ptype) - types;
33122 swig_type_info *ty = types_initial[shift];
33123 size_t ldoc = (c - methods[i].ml_doc);
33124 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33125 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33126 char *buff = ndoc;
33127 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33128 strncpy(buff, methods[i].ml_doc, ldoc);
33129 buff += ldoc;
33130 strncpy(buff, "swig_ptr: ", 10);
33131 buff += 10;
33132 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33133 methods[i].ml_doc = ndoc;
33134 }
33135 }
33136 }
33137 }
33138
33139 /* -----------------------------------------------------------------------------*
33140 * Initialize type list
33141 * -----------------------------------------------------------------------------*/
33142
33143 #if PY_MAJOR_VERSION < 2
33144 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33145 is copied out of Python/modsupport.c in python version 2.3.4 */
33146 static int
33147 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33148 {
33149 PyObject *dict;
33150 if (!PyModule_Check(m)) {
33151 PyErr_SetString(PyExc_TypeError,
33152 "PyModule_AddObject() needs module as first arg");
33153 return -1;
33154 }
33155 if (!o) {
33156 PyErr_SetString(PyExc_TypeError,
33157 "PyModule_AddObject() needs non-NULL value");
33158 return -1;
33159 }
33160
33161 dict = PyModule_GetDict(m);
33162 if (dict == NULL) {
33163 /* Internal error -- modules must have a dict! */
33164 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33165 PyModule_GetName(m));
33166 return -1;
33167 }
33168 if (PyDict_SetItemString(dict, name, o))
33169 return -1;
33170 Py_DECREF(o);
33171 return 0;
33172 }
33173 #endif
33174
33175 static swig_type_info **
33176 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33177 static PyMethodDef swig_empty_runtime_method_table[] = {
33178 {
33179 NULL, NULL, 0, NULL
33180 }
33181 };/* Sentinel */
33182
33183 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33184 swig_empty_runtime_method_table);
33185 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33186 if (pointer && module) {
33187 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33188 }
33189 return type_list_handle;
33190 }
33191
33192 static swig_type_info **
33193 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33194 swig_type_info **type_pointer;
33195
33196 /* first check if module already created */
33197 type_pointer = SWIG_Python_GetTypeListHandle();
33198 if (type_pointer) {
33199 return type_pointer;
33200 } else {
33201 /* create a new module and variable */
33202 return SWIG_Python_SetTypeListHandle(type_list_handle);
33203 }
33204 }
33205
33206 #ifdef __cplusplus
33207 }
33208 #endif
33209
33210 /* -----------------------------------------------------------------------------*
33211 * Partial Init method
33212 * -----------------------------------------------------------------------------*/
33213
33214 #ifdef SWIG_LINK_RUNTIME
33215 #ifdef __cplusplus
33216 extern "C"
33217 #endif
33218 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33219 #endif
33220
33221 #ifdef __cplusplus
33222 extern "C"
33223 #endif
33224 SWIGEXPORT(void) SWIG_init(void) {
33225 static PyObject *SWIG_globals = 0;
33226 static int typeinit = 0;
33227 PyObject *m, *d;
33228 int i;
33229 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33230
33231 /* Fix SwigMethods to carry the callback ptrs when needed */
33232 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33233
33234 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33235 d = PyModule_GetDict(m);
33236
33237 if (!typeinit) {
33238 #ifdef SWIG_LINK_RUNTIME
33239 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33240 #else
33241 # ifndef SWIG_STATIC_RUNTIME
33242 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33243 # endif
33244 #endif
33245 for (i = 0; swig_types_initial[i]; i++) {
33246 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33247 }
33248 typeinit = 1;
33249 }
33250 SWIG_InstallConstants(d,swig_const_table);
33251
33252 {
33253 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33254 }
33255 {
33256 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33257 }
33258 {
33259 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33260 }
33261 {
33262 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33266 }
33267 {
33268 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33269 }
33270 {
33271 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33272 }
33273 {
33274 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33275 }
33276 {
33277 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33278 }
33279 {
33280 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33284 }
33285 {
33286 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33287 }
33288 {
33289 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33290 }
33291 {
33292 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33293 }
33294 {
33295 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33296 }
33297 {
33298 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33299 }
33300 {
33301 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33302 }
33303 {
33304 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33305 }
33306 {
33307 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33308 }
33309 {
33310 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33311 }
33312 {
33313 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33314 }
33315 {
33316 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33317 }
33318 {
33319 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33320 }
33321 {
33322 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33323 }
33324 {
33325 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33326 }
33327 {
33328 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33329 }
33330 {
33331 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33332 }
33333 {
33334 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33359 }
33360 {
33361 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33362 }
33363 {
33364 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33365 }
33366 {
33367 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33368 }
33369 {
33370 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33371 }
33372 {
33373 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33374 }
33375 {
33376 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33377 }
33378 {
33379 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33380 }
33381 {
33382 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33383 }
33384 {
33385 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33386 }
33387 {
33388 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33389 }
33390 {
33391 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33392 }
33393 {
33394 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33395 }
33396 {
33397 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33398 }
33399 {
33400 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33401 }
33402 {
33403 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33404 }
33405 {
33406 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33407 }
33408 {
33409 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33410 }
33411 {
33412 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33413 }
33414 {
33415 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33416 }
33417 {
33418 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33419 }
33420 {
33421 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33422 }
33423 {
33424 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33425 }
33426 {
33427 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33428 }
33429 {
33430 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33431 }
33432 {
33433 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33434 }
33435 {
33436 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33437 }
33438 {
33439 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33440 }
33441 {
33442 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33443 }
33444 {
33445 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33446 }
33447 {
33448 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33449 }
33450 {
33451 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33452 }
33453 {
33454 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33455 }
33456 {
33457 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33458 }
33459 {
33460 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33461 }
33462 {
33463 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33464 }
33465 {
33466 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33467 }
33468 {
33469 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33470 }
33471 {
33472 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33473 }
33474 {
33475 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33476 }
33477 {
33478 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33479 }
33480 {
33481 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33482 }
33483 {
33484 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33485 }
33486 {
33487 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33488 }
33489 {
33490 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33491 }
33492 {
33493 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33494 }
33495 {
33496 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33497 }
33498 {
33499 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33509 }
33510 {
33511 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33512 }
33513 {
33514 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33515 }
33516 {
33517 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33518 }
33519 {
33520 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33521 }
33522 {
33523 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33524 }
33525 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33526 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33527 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33528 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33529 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33530 {
33531 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33541 }
33542 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33543
33544 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33545
33546 {
33547 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33548 }
33549 {
33550 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33551 }
33552 {
33553 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33578 }
33579 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33580 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33581 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33582 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33583 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33584 {
33585 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33676 }
33677 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33678 {
33679 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33692 }
33693
33694 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33695
33696 {
33697 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33716 }
33717 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33718 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33719 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33720 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33721 {
33722 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33744 }
33745 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33746 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33747 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33748 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33749 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33750 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33751 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33752 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33753 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33754 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33755 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33756 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33757 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33758 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33759 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33760 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33761 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33762 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33763 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33764 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33765 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33766 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33767 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33768 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33769 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33770 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33771 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33772 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33773 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33774 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33775 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33776 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33777 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33778 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33779 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33780 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33781 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33782 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33783 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33784 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33785 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33786 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33787 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33788 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33789 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33790 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33791 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33792 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33793 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33794 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33795 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33796 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33797 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33798 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33799 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33800 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33801
33802 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33803
33804 {
33805 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33830 }
33831 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33832 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33833 {
33834 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33835 }
33836 {
33837 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33838 }
33839 {
33840 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33841 }
33842 {
33843 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33844 }
33845 {
33846 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33847 }
33848 {
33849 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33850 }
33851 {
33852 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33853 }
33854 {
33855 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33856 }
33857 {
33858 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33859 }
33860 {
33861 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33862 }
33863 {
33864 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33865 }
33866 {
33867 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33868 }
33869 {
33870 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33871 }
33872 {
33873 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33874 }
33875 {
33876 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33877 }
33878 {
33879 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33880 }
33881 {
33882 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33883 }
33884 {
33885 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33886 }
33887 {
33888 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33913 }
33914 {
33915 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33916 }
33917 {
33918 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33919 }
33920 {
33921 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33922 }
33923 {
33924 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33925 }
33926 {
33927 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33928 }
33929 {
33930 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33931 }
33932 {
33933 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33934 }
33935 {
33936 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33937 }
33938 {
33939 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33940 }
33941 {
33942 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33943 }
33944 {
33945 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33946 }
33947 {
33948 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33949 }
33950 {
33951 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33952 }
33953 {
33954 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33955 }
33956 {
33957 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33958 }
33959 {
33960 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33961 }
33962 {
33963 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33964 }
33965 {
33966 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33967 }
33968 {
33969 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33970 }
33971 {
33972 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33973 }
33974 {
33975 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33976 }
33977 {
33978 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33979 }
33980 {
33981 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33982 }
33983 {
33984 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33985 }
33986 {
33987 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33988 }
33989 {
33990 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33991 }
33992 {
33993 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33994 }
33995 {
33996 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33997 }
33998 {
33999 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34000 }
34001 {
34002 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34003 }
34004 {
34005 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34006 }
34007 {
34008 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34009 }
34010 {
34011 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34012 }
34013 {
34014 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34015 }
34016 {
34017 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34018 }
34019 {
34020 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34021 }
34022 {
34023 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34024 }
34025 {
34026 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34027 }
34028 {
34029 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34030 }
34031 {
34032 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34033 }
34034 {
34035 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34036 }
34037 {
34038 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34039 }
34040 {
34041 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34042 }
34043 {
34044 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34045 }
34046 {
34047 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34048 }
34049 {
34050 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34051 }
34052 {
34053 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34054 }
34055 {
34056 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34057 }
34058 {
34059 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34060 }
34061 {
34062 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34063 }
34064 {
34065 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34066 }
34067 {
34068 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34069 }
34070 {
34071 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34072 }
34073 {
34074 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34075 }
34076 {
34077 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34078 }
34079 {
34080 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34081 }
34082 {
34083 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34084 }
34085 {
34086 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34087 }
34088 {
34089 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34090 }
34091 {
34092 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34093 }
34094 {
34095 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34096 }
34097 {
34098 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34099 }
34100 {
34101 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34102 }
34103 {
34104 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34105 }
34106 {
34107 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34108 }
34109 {
34110 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34111 }
34112 {
34113 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34114 }
34115 {
34116 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34117 }
34118 {
34119 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34120 }
34121 {
34122 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34123 }
34124 {
34125 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34126 }
34127 {
34128 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34129 }
34130 {
34131 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34132 }
34133 {
34134 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34135 }
34136 {
34137 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34138 }
34139 {
34140 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34141 }
34142 {
34143 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34144 }
34145 {
34146 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34147 }
34148 {
34149 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34150 }
34151 {
34152 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34153 }
34154 {
34155 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34156 }
34157 {
34158 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34159 }
34160 {
34161 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34162 }
34163 {
34164 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34165 }
34166 {
34167 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34168 }
34169 {
34170 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34171 }
34172 {
34173 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34174 }
34175 {
34176 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34177 }
34178 {
34179 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34180 }
34181 {
34182 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34183 }
34184 {
34185 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34186 }
34187 {
34188 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34246 }
34247 {
34248 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34297 }
34298 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34299 {
34300 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34358 }
34359 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34360 {
34361 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34395 }
34396
34397 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34398 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34399 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34400 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34401
34402 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34403 }
34404
wxWidgets (Impactor)