]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 iconIndex = loc.GetIndex();
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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2958 PyObject* pyList = NULL;
2959 wxArrayVideoModes arr = self->GetModes(mode);
2960 bool blocked = wxPyBeginBlockThreads();
2961 pyList = PyList_New(0);
2962 for (int i=0; i < arr.GetCount(); i++) {
2963 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2964 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2965 PyList_Append(pyList, pyObj);
2966 Py_DECREF(pyObj);
2967 }
2968 wxPyEndBlockThreads(blocked);
2969 return pyList;
2970 }
2971
2972 #include <wx/stdpaths.h>
2973
2974 static wxStandardPaths *StandardPaths_Get(){
2975 return (wxStandardPaths*) &wxStandardPaths::Get();
2976 }
2977 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2978 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2979 #ifdef __cplusplus
2980 extern "C" {
2981 #endif
2982 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2983 PyObject *resultobj;
2984 wxSystemColour arg1 ;
2985 wxColour result;
2986 PyObject * obj0 = 0 ;
2987 char *kwnames[] = {
2988 (char *) "index", NULL
2989 };
2990
2991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2992 {
2993 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2994 if (SWIG_arg_fail(1)) SWIG_fail;
2995 }
2996 {
2997 if (!wxPyCheckForApp()) SWIG_fail;
2998 PyThreadState* __tstate = wxPyBeginAllowThreads();
2999 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3000
3001 wxPyEndAllowThreads(__tstate);
3002 if (PyErr_Occurred()) SWIG_fail;
3003 }
3004 {
3005 wxColour * resultptr;
3006 resultptr = new wxColour((wxColour &)(result));
3007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3008 }
3009 return resultobj;
3010 fail:
3011 return NULL;
3012 }
3013
3014
3015 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3016 PyObject *resultobj;
3017 wxSystemFont arg1 ;
3018 wxFont result;
3019 PyObject * obj0 = 0 ;
3020 char *kwnames[] = {
3021 (char *) "index", NULL
3022 };
3023
3024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3025 {
3026 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3027 if (SWIG_arg_fail(1)) SWIG_fail;
3028 }
3029 {
3030 if (!wxPyCheckForApp()) SWIG_fail;
3031 PyThreadState* __tstate = wxPyBeginAllowThreads();
3032 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3033
3034 wxPyEndAllowThreads(__tstate);
3035 if (PyErr_Occurred()) SWIG_fail;
3036 }
3037 {
3038 wxFont * resultptr;
3039 resultptr = new wxFont((wxFont &)(result));
3040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3041 }
3042 return resultobj;
3043 fail:
3044 return NULL;
3045 }
3046
3047
3048 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3049 PyObject *resultobj;
3050 wxSystemMetric arg1 ;
3051 int result;
3052 PyObject * obj0 = 0 ;
3053 char *kwnames[] = {
3054 (char *) "index", NULL
3055 };
3056
3057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3058 {
3059 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3060 if (SWIG_arg_fail(1)) SWIG_fail;
3061 }
3062 {
3063 if (!wxPyCheckForApp()) SWIG_fail;
3064 PyThreadState* __tstate = wxPyBeginAllowThreads();
3065 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3066
3067 wxPyEndAllowThreads(__tstate);
3068 if (PyErr_Occurred()) SWIG_fail;
3069 }
3070 {
3071 resultobj = SWIG_From_int((int)(result));
3072 }
3073 return resultobj;
3074 fail:
3075 return NULL;
3076 }
3077
3078
3079 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3080 PyObject *resultobj;
3081 wxSystemFeature arg1 ;
3082 bool result;
3083 PyObject * obj0 = 0 ;
3084 char *kwnames[] = {
3085 (char *) "index", NULL
3086 };
3087
3088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3089 {
3090 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3091 if (SWIG_arg_fail(1)) SWIG_fail;
3092 }
3093 {
3094 if (!wxPyCheckForApp()) SWIG_fail;
3095 PyThreadState* __tstate = wxPyBeginAllowThreads();
3096 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3097
3098 wxPyEndAllowThreads(__tstate);
3099 if (PyErr_Occurred()) SWIG_fail;
3100 }
3101 {
3102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3103 }
3104 return resultobj;
3105 fail:
3106 return NULL;
3107 }
3108
3109
3110 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3111 PyObject *resultobj;
3112 wxSystemScreenType result;
3113 char *kwnames[] = {
3114 NULL
3115 };
3116
3117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3118 {
3119 if (!wxPyCheckForApp()) SWIG_fail;
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 resultobj = SWIG_From_int((result));
3127 return resultobj;
3128 fail:
3129 return NULL;
3130 }
3131
3132
3133 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3134 PyObject *resultobj;
3135 wxSystemScreenType arg1 ;
3136 PyObject * obj0 = 0 ;
3137 char *kwnames[] = {
3138 (char *) "screen", NULL
3139 };
3140
3141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3142 {
3143 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3144 if (SWIG_arg_fail(1)) SWIG_fail;
3145 }
3146 {
3147 if (!wxPyCheckForApp()) SWIG_fail;
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 Py_INCREF(Py_None); resultobj = Py_None;
3155 return resultobj;
3156 fail:
3157 return NULL;
3158 }
3159
3160
3161 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3162 PyObject *obj;
3163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3164 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3165 Py_INCREF(obj);
3166 return Py_BuildValue((char *)"");
3167 }
3168 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3169 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3170 return 1;
3171 }
3172
3173
3174 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3175 PyObject *pyobj;
3176
3177 {
3178 #if wxUSE_UNICODE
3179 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3180 #else
3181 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3182 #endif
3183 }
3184 return pyobj;
3185 }
3186
3187
3188 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3189 PyObject *resultobj;
3190 wxSystemOptions *result;
3191 char *kwnames[] = {
3192 NULL
3193 };
3194
3195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3196 {
3197 PyThreadState* __tstate = wxPyBeginAllowThreads();
3198 result = (wxSystemOptions *)new wxSystemOptions();
3199
3200 wxPyEndAllowThreads(__tstate);
3201 if (PyErr_Occurred()) SWIG_fail;
3202 }
3203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3204 return resultobj;
3205 fail:
3206 return NULL;
3207 }
3208
3209
3210 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3211 PyObject *resultobj;
3212 wxString *arg1 = 0 ;
3213 wxString *arg2 = 0 ;
3214 bool temp1 = false ;
3215 bool temp2 = false ;
3216 PyObject * obj0 = 0 ;
3217 PyObject * obj1 = 0 ;
3218 char *kwnames[] = {
3219 (char *) "name",(char *) "value", NULL
3220 };
3221
3222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3223 {
3224 arg1 = wxString_in_helper(obj0);
3225 if (arg1 == NULL) SWIG_fail;
3226 temp1 = true;
3227 }
3228 {
3229 arg2 = wxString_in_helper(obj1);
3230 if (arg2 == NULL) SWIG_fail;
3231 temp2 = true;
3232 }
3233 {
3234 PyThreadState* __tstate = wxPyBeginAllowThreads();
3235 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3236
3237 wxPyEndAllowThreads(__tstate);
3238 if (PyErr_Occurred()) SWIG_fail;
3239 }
3240 Py_INCREF(Py_None); resultobj = Py_None;
3241 {
3242 if (temp1)
3243 delete arg1;
3244 }
3245 {
3246 if (temp2)
3247 delete arg2;
3248 }
3249 return resultobj;
3250 fail:
3251 {
3252 if (temp1)
3253 delete arg1;
3254 }
3255 {
3256 if (temp2)
3257 delete arg2;
3258 }
3259 return NULL;
3260 }
3261
3262
3263 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3264 PyObject *resultobj;
3265 wxString *arg1 = 0 ;
3266 int arg2 ;
3267 bool temp1 = false ;
3268 PyObject * obj0 = 0 ;
3269 PyObject * obj1 = 0 ;
3270 char *kwnames[] = {
3271 (char *) "name",(char *) "value", NULL
3272 };
3273
3274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3275 {
3276 arg1 = wxString_in_helper(obj0);
3277 if (arg1 == NULL) SWIG_fail;
3278 temp1 = true;
3279 }
3280 {
3281 arg2 = (int)(SWIG_As_int(obj1));
3282 if (SWIG_arg_fail(2)) SWIG_fail;
3283 }
3284 {
3285 PyThreadState* __tstate = wxPyBeginAllowThreads();
3286 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3287
3288 wxPyEndAllowThreads(__tstate);
3289 if (PyErr_Occurred()) SWIG_fail;
3290 }
3291 Py_INCREF(Py_None); resultobj = Py_None;
3292 {
3293 if (temp1)
3294 delete arg1;
3295 }
3296 return resultobj;
3297 fail:
3298 {
3299 if (temp1)
3300 delete arg1;
3301 }
3302 return NULL;
3303 }
3304
3305
3306 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3307 PyObject *resultobj;
3308 wxString *arg1 = 0 ;
3309 wxString result;
3310 bool temp1 = false ;
3311 PyObject * obj0 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "name", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3317 {
3318 arg1 = wxString_in_helper(obj0);
3319 if (arg1 == NULL) SWIG_fail;
3320 temp1 = true;
3321 }
3322 {
3323 PyThreadState* __tstate = wxPyBeginAllowThreads();
3324 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3325
3326 wxPyEndAllowThreads(__tstate);
3327 if (PyErr_Occurred()) SWIG_fail;
3328 }
3329 {
3330 #if wxUSE_UNICODE
3331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3332 #else
3333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3334 #endif
3335 }
3336 {
3337 if (temp1)
3338 delete arg1;
3339 }
3340 return resultobj;
3341 fail:
3342 {
3343 if (temp1)
3344 delete arg1;
3345 }
3346 return NULL;
3347 }
3348
3349
3350 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3351 PyObject *resultobj;
3352 wxString *arg1 = 0 ;
3353 int result;
3354 bool temp1 = false ;
3355 PyObject * obj0 = 0 ;
3356 char *kwnames[] = {
3357 (char *) "name", NULL
3358 };
3359
3360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3361 {
3362 arg1 = wxString_in_helper(obj0);
3363 if (arg1 == NULL) SWIG_fail;
3364 temp1 = true;
3365 }
3366 {
3367 PyThreadState* __tstate = wxPyBeginAllowThreads();
3368 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3369
3370 wxPyEndAllowThreads(__tstate);
3371 if (PyErr_Occurred()) SWIG_fail;
3372 }
3373 {
3374 resultobj = SWIG_From_int((int)(result));
3375 }
3376 {
3377 if (temp1)
3378 delete arg1;
3379 }
3380 return resultobj;
3381 fail:
3382 {
3383 if (temp1)
3384 delete arg1;
3385 }
3386 return NULL;
3387 }
3388
3389
3390 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3391 PyObject *resultobj;
3392 wxString *arg1 = 0 ;
3393 bool result;
3394 bool temp1 = false ;
3395 PyObject * obj0 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "name", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3401 {
3402 arg1 = wxString_in_helper(obj0);
3403 if (arg1 == NULL) SWIG_fail;
3404 temp1 = true;
3405 }
3406 {
3407 PyThreadState* __tstate = wxPyBeginAllowThreads();
3408 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3409
3410 wxPyEndAllowThreads(__tstate);
3411 if (PyErr_Occurred()) SWIG_fail;
3412 }
3413 {
3414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3415 }
3416 {
3417 if (temp1)
3418 delete arg1;
3419 }
3420 return resultobj;
3421 fail:
3422 {
3423 if (temp1)
3424 delete arg1;
3425 }
3426 return NULL;
3427 }
3428
3429
3430 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3431 PyObject *obj;
3432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3433 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3434 Py_INCREF(obj);
3435 return Py_BuildValue((char *)"");
3436 }
3437 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3438 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3439 return 1;
3440 }
3441
3442
3443 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3444 PyObject *pyobj;
3445
3446 {
3447 #if wxUSE_UNICODE
3448 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3449 #else
3450 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3451 #endif
3452 }
3453 return pyobj;
3454 }
3455
3456
3457 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3458 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3459 return 1;
3460 }
3461
3462
3463 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3464 PyObject *pyobj;
3465
3466 {
3467 #if wxUSE_UNICODE
3468 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3469 #else
3470 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3471 #endif
3472 }
3473 return pyobj;
3474 }
3475
3476
3477 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3478 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3479 return 1;
3480 }
3481
3482
3483 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3484 PyObject *pyobj;
3485
3486 {
3487 #if wxUSE_UNICODE
3488 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3489 #else
3490 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3491 #endif
3492 }
3493 return pyobj;
3494 }
3495
3496
3497 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 long result;
3500 char *kwnames[] = {
3501 NULL
3502 };
3503
3504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3505 {
3506 PyThreadState* __tstate = wxPyBeginAllowThreads();
3507 result = (long)wxNewId();
3508
3509 wxPyEndAllowThreads(__tstate);
3510 if (PyErr_Occurred()) SWIG_fail;
3511 }
3512 {
3513 resultobj = SWIG_From_long((long)(result));
3514 }
3515 return resultobj;
3516 fail:
3517 return NULL;
3518 }
3519
3520
3521 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3522 PyObject *resultobj;
3523 long arg1 ;
3524 PyObject * obj0 = 0 ;
3525 char *kwnames[] = {
3526 (char *) "id", NULL
3527 };
3528
3529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3530 {
3531 arg1 = (long)(SWIG_As_long(obj0));
3532 if (SWIG_arg_fail(1)) SWIG_fail;
3533 }
3534 {
3535 PyThreadState* __tstate = wxPyBeginAllowThreads();
3536 wxRegisterId(arg1);
3537
3538 wxPyEndAllowThreads(__tstate);
3539 if (PyErr_Occurred()) SWIG_fail;
3540 }
3541 Py_INCREF(Py_None); resultobj = Py_None;
3542 return resultobj;
3543 fail:
3544 return NULL;
3545 }
3546
3547
3548 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3549 PyObject *resultobj;
3550 long result;
3551 char *kwnames[] = {
3552 NULL
3553 };
3554
3555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3556 {
3557 PyThreadState* __tstate = wxPyBeginAllowThreads();
3558 result = (long)wxGetCurrentId();
3559
3560 wxPyEndAllowThreads(__tstate);
3561 if (PyErr_Occurred()) SWIG_fail;
3562 }
3563 {
3564 resultobj = SWIG_From_long((long)(result));
3565 }
3566 return resultobj;
3567 fail:
3568 return NULL;
3569 }
3570
3571
3572 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3573 PyObject *resultobj;
3574 int arg1 ;
3575 bool result;
3576 PyObject * obj0 = 0 ;
3577 char *kwnames[] = {
3578 (char *) "id", NULL
3579 };
3580
3581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3582 {
3583 arg1 = (int)(SWIG_As_int(obj0));
3584 if (SWIG_arg_fail(1)) SWIG_fail;
3585 }
3586 {
3587 PyThreadState* __tstate = wxPyBeginAllowThreads();
3588 result = (bool)wxIsStockID(arg1);
3589
3590 wxPyEndAllowThreads(__tstate);
3591 if (PyErr_Occurred()) SWIG_fail;
3592 }
3593 {
3594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3595 }
3596 return resultobj;
3597 fail:
3598 return NULL;
3599 }
3600
3601
3602 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3603 PyObject *resultobj;
3604 int arg1 ;
3605 wxString *arg2 = 0 ;
3606 bool result;
3607 bool temp2 = false ;
3608 PyObject * obj0 = 0 ;
3609 PyObject * obj1 = 0 ;
3610 char *kwnames[] = {
3611 (char *) "id",(char *) "label", NULL
3612 };
3613
3614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3615 {
3616 arg1 = (int)(SWIG_As_int(obj0));
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 }
3619 {
3620 arg2 = wxString_in_helper(obj1);
3621 if (arg2 == NULL) SWIG_fail;
3622 temp2 = true;
3623 }
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 {
3632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3633 }
3634 {
3635 if (temp2)
3636 delete arg2;
3637 }
3638 return resultobj;
3639 fail:
3640 {
3641 if (temp2)
3642 delete arg2;
3643 }
3644 return NULL;
3645 }
3646
3647
3648 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3649 PyObject *resultobj;
3650 int arg1 ;
3651 bool arg2 = (bool) true ;
3652 wxString arg3 = (wxString) wxPyEmptyString ;
3653 wxString result;
3654 PyObject * obj0 = 0 ;
3655 PyObject * obj1 = 0 ;
3656 PyObject * obj2 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3662 {
3663 arg1 = (int)(SWIG_As_int(obj0));
3664 if (SWIG_arg_fail(1)) SWIG_fail;
3665 }
3666 if (obj1) {
3667 {
3668 arg2 = (bool)(SWIG_As_bool(obj1));
3669 if (SWIG_arg_fail(2)) SWIG_fail;
3670 }
3671 }
3672 if (obj2) {
3673 {
3674 wxString* sptr = wxString_in_helper(obj2);
3675 if (sptr == NULL) SWIG_fail;
3676 arg3 = *sptr;
3677 delete sptr;
3678 }
3679 }
3680 {
3681 PyThreadState* __tstate = wxPyBeginAllowThreads();
3682 result = wxGetStockLabel(arg1,arg2,arg3);
3683
3684 wxPyEndAllowThreads(__tstate);
3685 if (PyErr_Occurred()) SWIG_fail;
3686 }
3687 {
3688 #if wxUSE_UNICODE
3689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3690 #else
3691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3692 #endif
3693 }
3694 return resultobj;
3695 fail:
3696 return NULL;
3697 }
3698
3699
3700 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3701 PyObject *resultobj;
3702 char *kwnames[] = {
3703 NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3707 {
3708 if (!wxPyCheckForApp()) SWIG_fail;
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 wxBell();
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 char *kwnames[] = {
3725 NULL
3726 };
3727
3728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3729 {
3730 if (!wxPyCheckForApp()) SWIG_fail;
3731 PyThreadState* __tstate = wxPyBeginAllowThreads();
3732 wxEndBusyCursor();
3733
3734 wxPyEndAllowThreads(__tstate);
3735 if (PyErr_Occurred()) SWIG_fail;
3736 }
3737 Py_INCREF(Py_None); resultobj = Py_None;
3738 return resultobj;
3739 fail:
3740 return NULL;
3741 }
3742
3743
3744 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3745 PyObject *resultobj;
3746 bool arg1 = (bool) true ;
3747 long result;
3748 PyObject * obj0 = 0 ;
3749 char *kwnames[] = {
3750 (char *) "resetTimer", NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3754 if (obj0) {
3755 {
3756 arg1 = (bool)(SWIG_As_bool(obj0));
3757 if (SWIG_arg_fail(1)) SWIG_fail;
3758 }
3759 }
3760 {
3761 PyThreadState* __tstate = wxPyBeginAllowThreads();
3762 result = (long)wxGetElapsedTime(arg1);
3763
3764 wxPyEndAllowThreads(__tstate);
3765 if (PyErr_Occurred()) SWIG_fail;
3766 }
3767 {
3768 resultobj = SWIG_From_long((long)(result));
3769 }
3770 return resultobj;
3771 fail:
3772 return NULL;
3773 }
3774
3775
3776 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3777 PyObject *resultobj;
3778 int *arg1 = (int *) 0 ;
3779 int *arg2 = (int *) 0 ;
3780 int temp1 ;
3781 int res1 = 0 ;
3782 int temp2 ;
3783 int res2 = 0 ;
3784 char *kwnames[] = {
3785 NULL
3786 };
3787
3788 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3789 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3791 {
3792 if (!wxPyCheckForApp()) SWIG_fail;
3793 PyThreadState* __tstate = wxPyBeginAllowThreads();
3794 wxGetMousePosition(arg1,arg2);
3795
3796 wxPyEndAllowThreads(__tstate);
3797 if (PyErr_Occurred()) SWIG_fail;
3798 }
3799 Py_INCREF(Py_None); resultobj = Py_None;
3800 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3801 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3802 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3803 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3804 return resultobj;
3805 fail:
3806 return NULL;
3807 }
3808
3809
3810 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3811 PyObject *resultobj;
3812 bool result;
3813 char *kwnames[] = {
3814 NULL
3815 };
3816
3817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3818 {
3819 PyThreadState* __tstate = wxPyBeginAllowThreads();
3820 result = (bool)wxIsBusy();
3821
3822 wxPyEndAllowThreads(__tstate);
3823 if (PyErr_Occurred()) SWIG_fail;
3824 }
3825 {
3826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3827 }
3828 return resultobj;
3829 fail:
3830 return NULL;
3831 }
3832
3833
3834 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3835 PyObject *resultobj;
3836 wxString result;
3837 char *kwnames[] = {
3838 NULL
3839 };
3840
3841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3842 {
3843 PyThreadState* __tstate = wxPyBeginAllowThreads();
3844 result = wxNow();
3845
3846 wxPyEndAllowThreads(__tstate);
3847 if (PyErr_Occurred()) SWIG_fail;
3848 }
3849 {
3850 #if wxUSE_UNICODE
3851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3852 #else
3853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3854 #endif
3855 }
3856 return resultobj;
3857 fail:
3858 return NULL;
3859 }
3860
3861
3862 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3863 PyObject *resultobj;
3864 wxString const &arg1_defvalue = wxPyEmptyString ;
3865 wxString *arg1 = (wxString *) &arg1_defvalue ;
3866 bool result;
3867 bool temp1 = false ;
3868 PyObject * obj0 = 0 ;
3869 char *kwnames[] = {
3870 (char *) "command", NULL
3871 };
3872
3873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3874 if (obj0) {
3875 {
3876 arg1 = wxString_in_helper(obj0);
3877 if (arg1 == NULL) SWIG_fail;
3878 temp1 = true;
3879 }
3880 }
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (bool)wxShell((wxString const &)*arg1);
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3890 }
3891 {
3892 if (temp1)
3893 delete arg1;
3894 }
3895 return resultobj;
3896 fail:
3897 {
3898 if (temp1)
3899 delete arg1;
3900 }
3901 return NULL;
3902 }
3903
3904
3905 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3906 PyObject *resultobj;
3907 char *kwnames[] = {
3908 NULL
3909 };
3910
3911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 wxStartTimer();
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 Py_INCREF(Py_None); resultobj = Py_None;
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3927 PyObject *resultobj;
3928 int *arg1 = (int *) 0 ;
3929 int *arg2 = (int *) 0 ;
3930 int result;
3931 int temp1 ;
3932 int res1 = 0 ;
3933 int temp2 ;
3934 int res2 = 0 ;
3935 char *kwnames[] = {
3936 NULL
3937 };
3938
3939 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3940 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3942 {
3943 PyThreadState* __tstate = wxPyBeginAllowThreads();
3944 result = (int)wxGetOsVersion(arg1,arg2);
3945
3946 wxPyEndAllowThreads(__tstate);
3947 if (PyErr_Occurred()) SWIG_fail;
3948 }
3949 {
3950 resultobj = SWIG_From_int((int)(result));
3951 }
3952 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3953 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3954 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3955 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxString result;
3965 char *kwnames[] = {
3966 NULL
3967 };
3968
3969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3970 {
3971 PyThreadState* __tstate = wxPyBeginAllowThreads();
3972 result = wxGetOsDescription();
3973
3974 wxPyEndAllowThreads(__tstate);
3975 if (PyErr_Occurred()) SWIG_fail;
3976 }
3977 {
3978 #if wxUSE_UNICODE
3979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3980 #else
3981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3982 #endif
3983 }
3984 return resultobj;
3985 fail:
3986 return NULL;
3987 }
3988
3989
3990 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3991 PyObject *resultobj;
3992 long result;
3993 char *kwnames[] = {
3994 NULL
3995 };
3996
3997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3998 {
3999 PyThreadState* __tstate = wxPyBeginAllowThreads();
4000 result = (long)wxGetFreeMemory();
4001
4002 wxPyEndAllowThreads(__tstate);
4003 if (PyErr_Occurred()) SWIG_fail;
4004 }
4005 {
4006 resultobj = SWIG_From_long((long)(result));
4007 }
4008 return resultobj;
4009 fail:
4010 return NULL;
4011 }
4012
4013
4014 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4015 PyObject *resultobj;
4016 wxShutdownFlags arg1 ;
4017 bool result;
4018 PyObject * obj0 = 0 ;
4019 char *kwnames[] = {
4020 (char *) "wFlags", NULL
4021 };
4022
4023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4024 {
4025 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4026 if (SWIG_arg_fail(1)) SWIG_fail;
4027 }
4028 {
4029 if (!wxPyCheckForApp()) SWIG_fail;
4030 PyThreadState* __tstate = wxPyBeginAllowThreads();
4031 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4032
4033 wxPyEndAllowThreads(__tstate);
4034 if (PyErr_Occurred()) SWIG_fail;
4035 }
4036 {
4037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4038 }
4039 return resultobj;
4040 fail:
4041 return NULL;
4042 }
4043
4044
4045 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4046 PyObject *resultobj;
4047 int arg1 ;
4048 PyObject * obj0 = 0 ;
4049 char *kwnames[] = {
4050 (char *) "secs", NULL
4051 };
4052
4053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4054 {
4055 arg1 = (int)(SWIG_As_int(obj0));
4056 if (SWIG_arg_fail(1)) SWIG_fail;
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 wxSleep(arg1);
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 Py_INCREF(Py_None); resultobj = Py_None;
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 unsigned long arg1 ;
4075 PyObject * obj0 = 0 ;
4076 char *kwnames[] = {
4077 (char *) "milliseconds", NULL
4078 };
4079
4080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4081 {
4082 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4083 if (SWIG_arg_fail(1)) SWIG_fail;
4084 }
4085 {
4086 PyThreadState* __tstate = wxPyBeginAllowThreads();
4087 wxMilliSleep(arg1);
4088
4089 wxPyEndAllowThreads(__tstate);
4090 if (PyErr_Occurred()) SWIG_fail;
4091 }
4092 Py_INCREF(Py_None); resultobj = Py_None;
4093 return resultobj;
4094 fail:
4095 return NULL;
4096 }
4097
4098
4099 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj;
4101 unsigned long arg1 ;
4102 PyObject * obj0 = 0 ;
4103 char *kwnames[] = {
4104 (char *) "microseconds", NULL
4105 };
4106
4107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4108 {
4109 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4110 if (SWIG_arg_fail(1)) SWIG_fail;
4111 }
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 wxMicroSleep(arg1);
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 Py_INCREF(Py_None); resultobj = Py_None;
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj;
4128 bool arg1 ;
4129 PyObject * obj0 = 0 ;
4130 char *kwnames[] = {
4131 (char *) "enable", NULL
4132 };
4133
4134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4135 {
4136 arg1 = (bool)(SWIG_As_bool(obj0));
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 }
4139 {
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 wxEnableTopLevelWindows(arg1);
4142
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 Py_INCREF(Py_None); resultobj = Py_None;
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj;
4155 wxString *arg1 = 0 ;
4156 wxString result;
4157 bool temp1 = false ;
4158 PyObject * obj0 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "in", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4164 {
4165 arg1 = wxString_in_helper(obj0);
4166 if (arg1 == NULL) SWIG_fail;
4167 temp1 = true;
4168 }
4169 {
4170 PyThreadState* __tstate = wxPyBeginAllowThreads();
4171 result = wxStripMenuCodes((wxString const &)*arg1);
4172
4173 wxPyEndAllowThreads(__tstate);
4174 if (PyErr_Occurred()) SWIG_fail;
4175 }
4176 {
4177 #if wxUSE_UNICODE
4178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4179 #else
4180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4181 #endif
4182 }
4183 {
4184 if (temp1)
4185 delete arg1;
4186 }
4187 return resultobj;
4188 fail:
4189 {
4190 if (temp1)
4191 delete arg1;
4192 }
4193 return NULL;
4194 }
4195
4196
4197 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj;
4199 wxString result;
4200 char *kwnames[] = {
4201 NULL
4202 };
4203
4204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = wxGetEmailAddress();
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 {
4213 #if wxUSE_UNICODE
4214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4215 #else
4216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4217 #endif
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxString result;
4228 char *kwnames[] = {
4229 NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4233 {
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 result = wxGetHostName();
4236
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 {
4241 #if wxUSE_UNICODE
4242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4243 #else
4244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4245 #endif
4246 }
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj;
4255 wxString result;
4256 char *kwnames[] = {
4257 NULL
4258 };
4259
4260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 result = wxGetFullHostName();
4264
4265 wxPyEndAllowThreads(__tstate);
4266 if (PyErr_Occurred()) SWIG_fail;
4267 }
4268 {
4269 #if wxUSE_UNICODE
4270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4271 #else
4272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4273 #endif
4274 }
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxString result;
4284 char *kwnames[] = {
4285 NULL
4286 };
4287
4288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = wxGetUserId();
4292
4293 wxPyEndAllowThreads(__tstate);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 {
4297 #if wxUSE_UNICODE
4298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4299 #else
4300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4301 #endif
4302 }
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 wxString result;
4312 char *kwnames[] = {
4313 NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = wxGetUserName();
4320
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 {
4325 #if wxUSE_UNICODE
4326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4327 #else
4328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4329 #endif
4330 }
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxString result;
4340 char *kwnames[] = {
4341 NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 result = wxGetHomeDir();
4348
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 {
4353 #if wxUSE_UNICODE
4354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4355 #else
4356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4357 #endif
4358 }
4359 return resultobj;
4360 fail:
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 wxString const &arg1_defvalue = wxPyEmptyString ;
4368 wxString *arg1 = (wxString *) &arg1_defvalue ;
4369 wxString result;
4370 bool temp1 = false ;
4371 PyObject * obj0 = 0 ;
4372 char *kwnames[] = {
4373 (char *) "user", NULL
4374 };
4375
4376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4377 if (obj0) {
4378 {
4379 arg1 = wxString_in_helper(obj0);
4380 if (arg1 == NULL) SWIG_fail;
4381 temp1 = true;
4382 }
4383 }
4384 {
4385 PyThreadState* __tstate = wxPyBeginAllowThreads();
4386 result = wxGetUserHome((wxString const &)*arg1);
4387
4388 wxPyEndAllowThreads(__tstate);
4389 if (PyErr_Occurred()) SWIG_fail;
4390 }
4391 {
4392 #if wxUSE_UNICODE
4393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4394 #else
4395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4396 #endif
4397 }
4398 {
4399 if (temp1)
4400 delete arg1;
4401 }
4402 return resultobj;
4403 fail:
4404 {
4405 if (temp1)
4406 delete arg1;
4407 }
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 unsigned long result;
4415 char *kwnames[] = {
4416 NULL
4417 };
4418
4419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4420 {
4421 PyThreadState* __tstate = wxPyBeginAllowThreads();
4422 result = (unsigned long)wxGetProcessId();
4423
4424 wxPyEndAllowThreads(__tstate);
4425 if (PyErr_Occurred()) SWIG_fail;
4426 }
4427 {
4428 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4429 }
4430 return resultobj;
4431 fail:
4432 return NULL;
4433 }
4434
4435
4436 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4437 PyObject *resultobj;
4438 char *kwnames[] = {
4439 NULL
4440 };
4441
4442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 wxTrap();
4446
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 Py_INCREF(Py_None); resultobj = Py_None;
4451 return resultobj;
4452 fail:
4453 return NULL;
4454 }
4455
4456
4457 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4458 PyObject *resultobj;
4459 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4460 wxString *arg1 = (wxString *) &arg1_defvalue ;
4461 wxString const &arg2_defvalue = wxPyEmptyString ;
4462 wxString *arg2 = (wxString *) &arg2_defvalue ;
4463 wxString const &arg3_defvalue = wxPyEmptyString ;
4464 wxString *arg3 = (wxString *) &arg3_defvalue ;
4465 wxString const &arg4_defvalue = wxPyEmptyString ;
4466 wxString *arg4 = (wxString *) &arg4_defvalue ;
4467 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4468 wxString *arg5 = (wxString *) &arg5_defvalue ;
4469 int arg6 = (int) 0 ;
4470 wxWindow *arg7 = (wxWindow *) NULL ;
4471 int arg8 = (int) -1 ;
4472 int arg9 = (int) -1 ;
4473 wxString result;
4474 bool temp1 = false ;
4475 bool temp2 = false ;
4476 bool temp3 = false ;
4477 bool temp4 = false ;
4478 bool temp5 = false ;
4479 PyObject * obj0 = 0 ;
4480 PyObject * obj1 = 0 ;
4481 PyObject * obj2 = 0 ;
4482 PyObject * obj3 = 0 ;
4483 PyObject * obj4 = 0 ;
4484 PyObject * obj5 = 0 ;
4485 PyObject * obj6 = 0 ;
4486 PyObject * obj7 = 0 ;
4487 PyObject * obj8 = 0 ;
4488 char *kwnames[] = {
4489 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4490 };
4491
4492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4493 if (obj0) {
4494 {
4495 arg1 = wxString_in_helper(obj0);
4496 if (arg1 == NULL) SWIG_fail;
4497 temp1 = true;
4498 }
4499 }
4500 if (obj1) {
4501 {
4502 arg2 = wxString_in_helper(obj1);
4503 if (arg2 == NULL) SWIG_fail;
4504 temp2 = true;
4505 }
4506 }
4507 if (obj2) {
4508 {
4509 arg3 = wxString_in_helper(obj2);
4510 if (arg3 == NULL) SWIG_fail;
4511 temp3 = true;
4512 }
4513 }
4514 if (obj3) {
4515 {
4516 arg4 = wxString_in_helper(obj3);
4517 if (arg4 == NULL) SWIG_fail;
4518 temp4 = true;
4519 }
4520 }
4521 if (obj4) {
4522 {
4523 arg5 = wxString_in_helper(obj4);
4524 if (arg5 == NULL) SWIG_fail;
4525 temp5 = true;
4526 }
4527 }
4528 if (obj5) {
4529 {
4530 arg6 = (int)(SWIG_As_int(obj5));
4531 if (SWIG_arg_fail(6)) SWIG_fail;
4532 }
4533 }
4534 if (obj6) {
4535 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4536 if (SWIG_arg_fail(7)) SWIG_fail;
4537 }
4538 if (obj7) {
4539 {
4540 arg8 = (int)(SWIG_As_int(obj7));
4541 if (SWIG_arg_fail(8)) SWIG_fail;
4542 }
4543 }
4544 if (obj8) {
4545 {
4546 arg9 = (int)(SWIG_As_int(obj8));
4547 if (SWIG_arg_fail(9)) SWIG_fail;
4548 }
4549 }
4550 {
4551 if (!wxPyCheckForApp()) SWIG_fail;
4552 PyThreadState* __tstate = wxPyBeginAllowThreads();
4553 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4554
4555 wxPyEndAllowThreads(__tstate);
4556 if (PyErr_Occurred()) SWIG_fail;
4557 }
4558 {
4559 #if wxUSE_UNICODE
4560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4561 #else
4562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4563 #endif
4564 }
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 {
4570 if (temp2)
4571 delete arg2;
4572 }
4573 {
4574 if (temp3)
4575 delete arg3;
4576 }
4577 {
4578 if (temp4)
4579 delete arg4;
4580 }
4581 {
4582 if (temp5)
4583 delete arg5;
4584 }
4585 return resultobj;
4586 fail:
4587 {
4588 if (temp1)
4589 delete arg1;
4590 }
4591 {
4592 if (temp2)
4593 delete arg2;
4594 }
4595 {
4596 if (temp3)
4597 delete arg3;
4598 }
4599 {
4600 if (temp4)
4601 delete arg4;
4602 }
4603 {
4604 if (temp5)
4605 delete arg5;
4606 }
4607 return NULL;
4608 }
4609
4610
4611 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4612 PyObject *resultobj;
4613 wxString *arg1 = 0 ;
4614 wxString *arg2 = 0 ;
4615 wxString const &arg3_defvalue = wxPyEmptyString ;
4616 wxString *arg3 = (wxString *) &arg3_defvalue ;
4617 wxWindow *arg4 = (wxWindow *) NULL ;
4618 wxString result;
4619 bool temp1 = false ;
4620 bool temp2 = false ;
4621 bool temp3 = false ;
4622 PyObject * obj0 = 0 ;
4623 PyObject * obj1 = 0 ;
4624 PyObject * obj2 = 0 ;
4625 PyObject * obj3 = 0 ;
4626 char *kwnames[] = {
4627 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4628 };
4629
4630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4631 {
4632 arg1 = wxString_in_helper(obj0);
4633 if (arg1 == NULL) SWIG_fail;
4634 temp1 = true;
4635 }
4636 {
4637 arg2 = wxString_in_helper(obj1);
4638 if (arg2 == NULL) SWIG_fail;
4639 temp2 = true;
4640 }
4641 if (obj2) {
4642 {
4643 arg3 = wxString_in_helper(obj2);
4644 if (arg3 == NULL) SWIG_fail;
4645 temp3 = true;
4646 }
4647 }
4648 if (obj3) {
4649 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4650 if (SWIG_arg_fail(4)) SWIG_fail;
4651 }
4652 {
4653 if (!wxPyCheckForApp()) SWIG_fail;
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4656
4657 wxPyEndAllowThreads(__tstate);
4658 if (PyErr_Occurred()) SWIG_fail;
4659 }
4660 {
4661 #if wxUSE_UNICODE
4662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4663 #else
4664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4665 #endif
4666 }
4667 {
4668 if (temp1)
4669 delete arg1;
4670 }
4671 {
4672 if (temp2)
4673 delete arg2;
4674 }
4675 {
4676 if (temp3)
4677 delete arg3;
4678 }
4679 return resultobj;
4680 fail:
4681 {
4682 if (temp1)
4683 delete arg1;
4684 }
4685 {
4686 if (temp2)
4687 delete arg2;
4688 }
4689 {
4690 if (temp3)
4691 delete arg3;
4692 }
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj;
4699 wxString *arg1 = 0 ;
4700 wxString *arg2 = 0 ;
4701 wxString const &arg3_defvalue = wxPyEmptyString ;
4702 wxString *arg3 = (wxString *) &arg3_defvalue ;
4703 wxWindow *arg4 = (wxWindow *) NULL ;
4704 wxString result;
4705 bool temp1 = false ;
4706 bool temp2 = false ;
4707 bool temp3 = false ;
4708 PyObject * obj0 = 0 ;
4709 PyObject * obj1 = 0 ;
4710 PyObject * obj2 = 0 ;
4711 PyObject * obj3 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4717 {
4718 arg1 = wxString_in_helper(obj0);
4719 if (arg1 == NULL) SWIG_fail;
4720 temp1 = true;
4721 }
4722 {
4723 arg2 = wxString_in_helper(obj1);
4724 if (arg2 == NULL) SWIG_fail;
4725 temp2 = true;
4726 }
4727 if (obj2) {
4728 {
4729 arg3 = wxString_in_helper(obj2);
4730 if (arg3 == NULL) SWIG_fail;
4731 temp3 = true;
4732 }
4733 }
4734 if (obj3) {
4735 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(4)) SWIG_fail;
4737 }
4738 {
4739 if (!wxPyCheckForApp()) SWIG_fail;
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4742
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 {
4747 #if wxUSE_UNICODE
4748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4749 #else
4750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4751 #endif
4752 }
4753 {
4754 if (temp1)
4755 delete arg1;
4756 }
4757 {
4758 if (temp2)
4759 delete arg2;
4760 }
4761 {
4762 if (temp3)
4763 delete arg3;
4764 }
4765 return resultobj;
4766 fail:
4767 {
4768 if (temp1)
4769 delete arg1;
4770 }
4771 {
4772 if (temp2)
4773 delete arg2;
4774 }
4775 {
4776 if (temp3)
4777 delete arg3;
4778 }
4779 return NULL;
4780 }
4781
4782
4783 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4784 PyObject *resultobj;
4785 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4786 wxString *arg1 = (wxString *) &arg1_defvalue ;
4787 wxString const &arg2_defvalue = wxPyEmptyString ;
4788 wxString *arg2 = (wxString *) &arg2_defvalue ;
4789 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4790 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4791 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4792 wxWindow *arg5 = (wxWindow *) NULL ;
4793 wxString result;
4794 bool temp1 = false ;
4795 bool temp2 = false ;
4796 wxPoint temp4 ;
4797 PyObject * obj0 = 0 ;
4798 PyObject * obj1 = 0 ;
4799 PyObject * obj2 = 0 ;
4800 PyObject * obj3 = 0 ;
4801 PyObject * obj4 = 0 ;
4802 char *kwnames[] = {
4803 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4804 };
4805
4806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4807 if (obj0) {
4808 {
4809 arg1 = wxString_in_helper(obj0);
4810 if (arg1 == NULL) SWIG_fail;
4811 temp1 = true;
4812 }
4813 }
4814 if (obj1) {
4815 {
4816 arg2 = wxString_in_helper(obj1);
4817 if (arg2 == NULL) SWIG_fail;
4818 temp2 = true;
4819 }
4820 }
4821 if (obj2) {
4822 {
4823 arg3 = (long)(SWIG_As_long(obj2));
4824 if (SWIG_arg_fail(3)) SWIG_fail;
4825 }
4826 }
4827 if (obj3) {
4828 {
4829 arg4 = &temp4;
4830 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4831 }
4832 }
4833 if (obj4) {
4834 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4835 if (SWIG_arg_fail(5)) SWIG_fail;
4836 }
4837 {
4838 if (!wxPyCheckForApp()) SWIG_fail;
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4841
4842 wxPyEndAllowThreads(__tstate);
4843 if (PyErr_Occurred()) SWIG_fail;
4844 }
4845 {
4846 #if wxUSE_UNICODE
4847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4848 #else
4849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4850 #endif
4851 }
4852 {
4853 if (temp1)
4854 delete arg1;
4855 }
4856 {
4857 if (temp2)
4858 delete arg2;
4859 }
4860 return resultobj;
4861 fail:
4862 {
4863 if (temp1)
4864 delete arg1;
4865 }
4866 {
4867 if (temp2)
4868 delete arg2;
4869 }
4870 return NULL;
4871 }
4872
4873
4874 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4875 PyObject *resultobj;
4876 wxString *arg1 = 0 ;
4877 wxString const &arg2_defvalue = wxPyEmptyString ;
4878 wxString *arg2 = (wxString *) &arg2_defvalue ;
4879 wxString const &arg3_defvalue = wxPyEmptyString ;
4880 wxString *arg3 = (wxString *) &arg3_defvalue ;
4881 wxWindow *arg4 = (wxWindow *) NULL ;
4882 int arg5 = (int) -1 ;
4883 int arg6 = (int) -1 ;
4884 bool arg7 = (bool) true ;
4885 wxString result;
4886 bool temp1 = false ;
4887 bool temp2 = false ;
4888 bool temp3 = false ;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 PyObject * obj2 = 0 ;
4892 PyObject * obj3 = 0 ;
4893 PyObject * obj4 = 0 ;
4894 PyObject * obj5 = 0 ;
4895 PyObject * obj6 = 0 ;
4896 char *kwnames[] = {
4897 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4898 };
4899
4900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4901 {
4902 arg1 = wxString_in_helper(obj0);
4903 if (arg1 == NULL) SWIG_fail;
4904 temp1 = true;
4905 }
4906 if (obj1) {
4907 {
4908 arg2 = wxString_in_helper(obj1);
4909 if (arg2 == NULL) SWIG_fail;
4910 temp2 = true;
4911 }
4912 }
4913 if (obj2) {
4914 {
4915 arg3 = wxString_in_helper(obj2);
4916 if (arg3 == NULL) SWIG_fail;
4917 temp3 = true;
4918 }
4919 }
4920 if (obj3) {
4921 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4922 if (SWIG_arg_fail(4)) SWIG_fail;
4923 }
4924 if (obj4) {
4925 {
4926 arg5 = (int)(SWIG_As_int(obj4));
4927 if (SWIG_arg_fail(5)) SWIG_fail;
4928 }
4929 }
4930 if (obj5) {
4931 {
4932 arg6 = (int)(SWIG_As_int(obj5));
4933 if (SWIG_arg_fail(6)) SWIG_fail;
4934 }
4935 }
4936 if (obj6) {
4937 {
4938 arg7 = (bool)(SWIG_As_bool(obj6));
4939 if (SWIG_arg_fail(7)) SWIG_fail;
4940 }
4941 }
4942 {
4943 if (!wxPyCheckForApp()) SWIG_fail;
4944 PyThreadState* __tstate = wxPyBeginAllowThreads();
4945 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4946
4947 wxPyEndAllowThreads(__tstate);
4948 if (PyErr_Occurred()) SWIG_fail;
4949 }
4950 {
4951 #if wxUSE_UNICODE
4952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4953 #else
4954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4955 #endif
4956 }
4957 {
4958 if (temp1)
4959 delete arg1;
4960 }
4961 {
4962 if (temp2)
4963 delete arg2;
4964 }
4965 {
4966 if (temp3)
4967 delete arg3;
4968 }
4969 return resultobj;
4970 fail:
4971 {
4972 if (temp1)
4973 delete arg1;
4974 }
4975 {
4976 if (temp2)
4977 delete arg2;
4978 }
4979 {
4980 if (temp3)
4981 delete arg3;
4982 }
4983 return NULL;
4984 }
4985
4986
4987 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj;
4989 wxString *arg1 = 0 ;
4990 wxString const &arg2_defvalue = wxPyEmptyString ;
4991 wxString *arg2 = (wxString *) &arg2_defvalue ;
4992 wxString const &arg3_defvalue = wxPyEmptyString ;
4993 wxString *arg3 = (wxString *) &arg3_defvalue ;
4994 wxWindow *arg4 = (wxWindow *) NULL ;
4995 wxString result;
4996 bool temp1 = false ;
4997 bool temp2 = false ;
4998 bool temp3 = false ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 PyObject * obj2 = 0 ;
5002 PyObject * obj3 = 0 ;
5003 char *kwnames[] = {
5004 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5005 };
5006
5007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5008 {
5009 arg1 = wxString_in_helper(obj0);
5010 if (arg1 == NULL) SWIG_fail;
5011 temp1 = true;
5012 }
5013 if (obj1) {
5014 {
5015 arg2 = wxString_in_helper(obj1);
5016 if (arg2 == NULL) SWIG_fail;
5017 temp2 = true;
5018 }
5019 }
5020 if (obj2) {
5021 {
5022 arg3 = wxString_in_helper(obj2);
5023 if (arg3 == NULL) SWIG_fail;
5024 temp3 = true;
5025 }
5026 }
5027 if (obj3) {
5028 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(4)) SWIG_fail;
5030 }
5031 {
5032 if (!wxPyCheckForApp()) SWIG_fail;
5033 PyThreadState* __tstate = wxPyBeginAllowThreads();
5034 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5035
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 {
5040 #if wxUSE_UNICODE
5041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5042 #else
5043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5044 #endif
5045 }
5046 {
5047 if (temp1)
5048 delete arg1;
5049 }
5050 {
5051 if (temp2)
5052 delete arg2;
5053 }
5054 {
5055 if (temp3)
5056 delete arg3;
5057 }
5058 return resultobj;
5059 fail:
5060 {
5061 if (temp1)
5062 delete arg1;
5063 }
5064 {
5065 if (temp2)
5066 delete arg2;
5067 }
5068 {
5069 if (temp3)
5070 delete arg3;
5071 }
5072 return NULL;
5073 }
5074
5075
5076 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5077 PyObject *resultobj;
5078 wxString *arg1 = 0 ;
5079 wxString *arg2 = 0 ;
5080 int arg3 ;
5081 wxString *arg4 = (wxString *) 0 ;
5082 wxWindow *arg5 = (wxWindow *) NULL ;
5083 int arg6 = (int) -1 ;
5084 int arg7 = (int) -1 ;
5085 bool arg8 = (bool) true ;
5086 int arg9 = (int) 150 ;
5087 int arg10 = (int) 200 ;
5088 wxString result;
5089 bool temp1 = false ;
5090 bool temp2 = false ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 PyObject * obj3 = 0 ;
5095 PyObject * obj4 = 0 ;
5096 PyObject * obj5 = 0 ;
5097 PyObject * obj6 = 0 ;
5098 PyObject * obj7 = 0 ;
5099 PyObject * obj8 = 0 ;
5100 char *kwnames[] = {
5101 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5102 };
5103
5104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5105 {
5106 arg1 = wxString_in_helper(obj0);
5107 if (arg1 == NULL) SWIG_fail;
5108 temp1 = true;
5109 }
5110 {
5111 arg2 = wxString_in_helper(obj1);
5112 if (arg2 == NULL) SWIG_fail;
5113 temp2 = true;
5114 }
5115 {
5116 arg3 = PyList_Size(obj2);
5117 arg4 = wxString_LIST_helper(obj2);
5118 if (arg4 == NULL) SWIG_fail;
5119 }
5120 if (obj3) {
5121 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(5)) SWIG_fail;
5123 }
5124 if (obj4) {
5125 {
5126 arg6 = (int)(SWIG_As_int(obj4));
5127 if (SWIG_arg_fail(6)) SWIG_fail;
5128 }
5129 }
5130 if (obj5) {
5131 {
5132 arg7 = (int)(SWIG_As_int(obj5));
5133 if (SWIG_arg_fail(7)) SWIG_fail;
5134 }
5135 }
5136 if (obj6) {
5137 {
5138 arg8 = (bool)(SWIG_As_bool(obj6));
5139 if (SWIG_arg_fail(8)) SWIG_fail;
5140 }
5141 }
5142 if (obj7) {
5143 {
5144 arg9 = (int)(SWIG_As_int(obj7));
5145 if (SWIG_arg_fail(9)) SWIG_fail;
5146 }
5147 }
5148 if (obj8) {
5149 {
5150 arg10 = (int)(SWIG_As_int(obj8));
5151 if (SWIG_arg_fail(10)) SWIG_fail;
5152 }
5153 }
5154 {
5155 if (!wxPyCheckForApp()) SWIG_fail;
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 {
5163 #if wxUSE_UNICODE
5164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5165 #else
5166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5167 #endif
5168 }
5169 {
5170 if (temp1)
5171 delete arg1;
5172 }
5173 {
5174 if (temp2)
5175 delete arg2;
5176 }
5177 {
5178 if (arg4) delete [] arg4;
5179 }
5180 return resultobj;
5181 fail:
5182 {
5183 if (temp1)
5184 delete arg1;
5185 }
5186 {
5187 if (temp2)
5188 delete arg2;
5189 }
5190 {
5191 if (arg4) delete [] arg4;
5192 }
5193 return NULL;
5194 }
5195
5196
5197 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj;
5199 wxString *arg1 = 0 ;
5200 wxString *arg2 = 0 ;
5201 int arg3 ;
5202 wxString *arg4 = (wxString *) 0 ;
5203 wxWindow *arg5 = (wxWindow *) NULL ;
5204 int arg6 = (int) -1 ;
5205 int arg7 = (int) -1 ;
5206 bool arg8 = (bool) true ;
5207 int arg9 = (int) 150 ;
5208 int arg10 = (int) 200 ;
5209 int result;
5210 bool temp1 = false ;
5211 bool temp2 = false ;
5212 PyObject * obj0 = 0 ;
5213 PyObject * obj1 = 0 ;
5214 PyObject * obj2 = 0 ;
5215 PyObject * obj3 = 0 ;
5216 PyObject * obj4 = 0 ;
5217 PyObject * obj5 = 0 ;
5218 PyObject * obj6 = 0 ;
5219 PyObject * obj7 = 0 ;
5220 PyObject * obj8 = 0 ;
5221 char *kwnames[] = {
5222 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5223 };
5224
5225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5226 {
5227 arg1 = wxString_in_helper(obj0);
5228 if (arg1 == NULL) SWIG_fail;
5229 temp1 = true;
5230 }
5231 {
5232 arg2 = wxString_in_helper(obj1);
5233 if (arg2 == NULL) SWIG_fail;
5234 temp2 = true;
5235 }
5236 {
5237 arg3 = PyList_Size(obj2);
5238 arg4 = wxString_LIST_helper(obj2);
5239 if (arg4 == NULL) SWIG_fail;
5240 }
5241 if (obj3) {
5242 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5243 if (SWIG_arg_fail(5)) SWIG_fail;
5244 }
5245 if (obj4) {
5246 {
5247 arg6 = (int)(SWIG_As_int(obj4));
5248 if (SWIG_arg_fail(6)) SWIG_fail;
5249 }
5250 }
5251 if (obj5) {
5252 {
5253 arg7 = (int)(SWIG_As_int(obj5));
5254 if (SWIG_arg_fail(7)) SWIG_fail;
5255 }
5256 }
5257 if (obj6) {
5258 {
5259 arg8 = (bool)(SWIG_As_bool(obj6));
5260 if (SWIG_arg_fail(8)) SWIG_fail;
5261 }
5262 }
5263 if (obj7) {
5264 {
5265 arg9 = (int)(SWIG_As_int(obj7));
5266 if (SWIG_arg_fail(9)) SWIG_fail;
5267 }
5268 }
5269 if (obj8) {
5270 {
5271 arg10 = (int)(SWIG_As_int(obj8));
5272 if (SWIG_arg_fail(10)) SWIG_fail;
5273 }
5274 }
5275 {
5276 if (!wxPyCheckForApp()) SWIG_fail;
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5279
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 {
5284 resultobj = SWIG_From_int((int)(result));
5285 }
5286 {
5287 if (temp1)
5288 delete arg1;
5289 }
5290 {
5291 if (temp2)
5292 delete arg2;
5293 }
5294 {
5295 if (arg4) delete [] arg4;
5296 }
5297 return resultobj;
5298 fail:
5299 {
5300 if (temp1)
5301 delete arg1;
5302 }
5303 {
5304 if (temp2)
5305 delete arg2;
5306 }
5307 {
5308 if (arg4) delete [] arg4;
5309 }
5310 return NULL;
5311 }
5312
5313
5314 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj;
5316 wxString *arg1 = 0 ;
5317 wxString const &arg2_defvalue = wxPyEmptyString ;
5318 wxString *arg2 = (wxString *) &arg2_defvalue ;
5319 int arg3 = (int) wxOK|wxCENTRE ;
5320 wxWindow *arg4 = (wxWindow *) NULL ;
5321 int arg5 = (int) -1 ;
5322 int arg6 = (int) -1 ;
5323 int result;
5324 bool temp1 = false ;
5325 bool temp2 = false ;
5326 PyObject * obj0 = 0 ;
5327 PyObject * obj1 = 0 ;
5328 PyObject * obj2 = 0 ;
5329 PyObject * obj3 = 0 ;
5330 PyObject * obj4 = 0 ;
5331 PyObject * obj5 = 0 ;
5332 char *kwnames[] = {
5333 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5334 };
5335
5336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5337 {
5338 arg1 = wxString_in_helper(obj0);
5339 if (arg1 == NULL) SWIG_fail;
5340 temp1 = true;
5341 }
5342 if (obj1) {
5343 {
5344 arg2 = wxString_in_helper(obj1);
5345 if (arg2 == NULL) SWIG_fail;
5346 temp2 = true;
5347 }
5348 }
5349 if (obj2) {
5350 {
5351 arg3 = (int)(SWIG_As_int(obj2));
5352 if (SWIG_arg_fail(3)) SWIG_fail;
5353 }
5354 }
5355 if (obj3) {
5356 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5357 if (SWIG_arg_fail(4)) SWIG_fail;
5358 }
5359 if (obj4) {
5360 {
5361 arg5 = (int)(SWIG_As_int(obj4));
5362 if (SWIG_arg_fail(5)) SWIG_fail;
5363 }
5364 }
5365 if (obj5) {
5366 {
5367 arg6 = (int)(SWIG_As_int(obj5));
5368 if (SWIG_arg_fail(6)) SWIG_fail;
5369 }
5370 }
5371 {
5372 if (!wxPyCheckForApp()) SWIG_fail;
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5375
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 resultobj = SWIG_From_int((int)(result));
5381 }
5382 {
5383 if (temp1)
5384 delete arg1;
5385 }
5386 {
5387 if (temp2)
5388 delete arg2;
5389 }
5390 return resultobj;
5391 fail:
5392 {
5393 if (temp1)
5394 delete arg1;
5395 }
5396 {
5397 if (temp2)
5398 delete arg2;
5399 }
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxString *arg1 = 0 ;
5407 wxString *arg2 = 0 ;
5408 wxString *arg3 = 0 ;
5409 long arg4 ;
5410 long arg5 = (long) 0 ;
5411 long arg6 = (long) 100 ;
5412 wxWindow *arg7 = (wxWindow *) NULL ;
5413 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5414 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5415 long result;
5416 bool temp1 = false ;
5417 bool temp2 = false ;
5418 bool temp3 = false ;
5419 wxPoint temp8 ;
5420 PyObject * obj0 = 0 ;
5421 PyObject * obj1 = 0 ;
5422 PyObject * obj2 = 0 ;
5423 PyObject * obj3 = 0 ;
5424 PyObject * obj4 = 0 ;
5425 PyObject * obj5 = 0 ;
5426 PyObject * obj6 = 0 ;
5427 PyObject * obj7 = 0 ;
5428 char *kwnames[] = {
5429 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5430 };
5431
5432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5433 {
5434 arg1 = wxString_in_helper(obj0);
5435 if (arg1 == NULL) SWIG_fail;
5436 temp1 = true;
5437 }
5438 {
5439 arg2 = wxString_in_helper(obj1);
5440 if (arg2 == NULL) SWIG_fail;
5441 temp2 = true;
5442 }
5443 {
5444 arg3 = wxString_in_helper(obj2);
5445 if (arg3 == NULL) SWIG_fail;
5446 temp3 = true;
5447 }
5448 {
5449 arg4 = (long)(SWIG_As_long(obj3));
5450 if (SWIG_arg_fail(4)) SWIG_fail;
5451 }
5452 if (obj4) {
5453 {
5454 arg5 = (long)(SWIG_As_long(obj4));
5455 if (SWIG_arg_fail(5)) SWIG_fail;
5456 }
5457 }
5458 if (obj5) {
5459 {
5460 arg6 = (long)(SWIG_As_long(obj5));
5461 if (SWIG_arg_fail(6)) SWIG_fail;
5462 }
5463 }
5464 if (obj6) {
5465 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5466 if (SWIG_arg_fail(7)) SWIG_fail;
5467 }
5468 if (obj7) {
5469 {
5470 arg8 = &temp8;
5471 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5472 }
5473 }
5474 {
5475 if (!wxPyCheckForApp()) SWIG_fail;
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5478
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = SWIG_From_long((long)(result));
5484 }
5485 {
5486 if (temp1)
5487 delete arg1;
5488 }
5489 {
5490 if (temp2)
5491 delete arg2;
5492 }
5493 {
5494 if (temp3)
5495 delete arg3;
5496 }
5497 return resultobj;
5498 fail:
5499 {
5500 if (temp1)
5501 delete arg1;
5502 }
5503 {
5504 if (temp2)
5505 delete arg2;
5506 }
5507 {
5508 if (temp3)
5509 delete arg3;
5510 }
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 bool result;
5518 char *kwnames[] = {
5519 NULL
5520 };
5521
5522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5523 {
5524 if (!wxPyCheckForApp()) SWIG_fail;
5525 PyThreadState* __tstate = wxPyBeginAllowThreads();
5526 result = (bool)wxColourDisplay();
5527
5528 wxPyEndAllowThreads(__tstate);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj;
5542 int result;
5543 char *kwnames[] = {
5544 NULL
5545 };
5546
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5548 {
5549 if (!wxPyCheckForApp()) SWIG_fail;
5550 PyThreadState* __tstate = wxPyBeginAllowThreads();
5551 result = (int)wxDisplayDepth();
5552
5553 wxPyEndAllowThreads(__tstate);
5554 if (PyErr_Occurred()) SWIG_fail;
5555 }
5556 {
5557 resultobj = SWIG_From_int((int)(result));
5558 }
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5566 PyObject *resultobj;
5567 int result;
5568 char *kwnames[] = {
5569 NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5573 {
5574 if (!wxPyCheckForApp()) SWIG_fail;
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (int)wxGetDisplayDepth();
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 {
5582 resultobj = SWIG_From_int((int)(result));
5583 }
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5591 PyObject *resultobj;
5592 int *arg1 = (int *) 0 ;
5593 int *arg2 = (int *) 0 ;
5594 int temp1 ;
5595 int res1 = 0 ;
5596 int temp2 ;
5597 int res2 = 0 ;
5598 char *kwnames[] = {
5599 NULL
5600 };
5601
5602 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5603 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5605 {
5606 if (!wxPyCheckForApp()) SWIG_fail;
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 wxDisplaySize(arg1,arg2);
5609
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 Py_INCREF(Py_None); resultobj = Py_None;
5614 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5615 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5616 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5617 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxSize result;
5627 char *kwnames[] = {
5628 NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5632 {
5633 if (!wxPyCheckForApp()) SWIG_fail;
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = wxGetDisplaySize();
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 {
5641 wxSize * resultptr;
5642 resultptr = new wxSize((wxSize &)(result));
5643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5644 }
5645 return resultobj;
5646 fail:
5647 return NULL;
5648 }
5649
5650
5651 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5652 PyObject *resultobj;
5653 int *arg1 = (int *) 0 ;
5654 int *arg2 = (int *) 0 ;
5655 int temp1 ;
5656 int res1 = 0 ;
5657 int temp2 ;
5658 int res2 = 0 ;
5659 char *kwnames[] = {
5660 NULL
5661 };
5662
5663 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5664 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5666 {
5667 if (!wxPyCheckForApp()) SWIG_fail;
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 wxDisplaySizeMM(arg1,arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5676 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5677 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5678 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj;
5687 wxSize result;
5688 char *kwnames[] = {
5689 NULL
5690 };
5691
5692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5693 {
5694 if (!wxPyCheckForApp()) SWIG_fail;
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = wxGetDisplaySizeMM();
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 {
5702 wxSize * resultptr;
5703 resultptr = new wxSize((wxSize &)(result));
5704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5705 }
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 int *arg1 = (int *) 0 ;
5715 int *arg2 = (int *) 0 ;
5716 int *arg3 = (int *) 0 ;
5717 int *arg4 = (int *) 0 ;
5718 int temp1 ;
5719 int res1 = 0 ;
5720 int temp2 ;
5721 int res2 = 0 ;
5722 int temp3 ;
5723 int res3 = 0 ;
5724 int temp4 ;
5725 int res4 = 0 ;
5726 char *kwnames[] = {
5727 NULL
5728 };
5729
5730 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5731 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5732 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5733 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5735 {
5736 if (!wxPyCheckForApp()) SWIG_fail;
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5739
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 Py_INCREF(Py_None); resultobj = Py_None;
5744 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5745 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5746 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5747 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5748 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5749 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5750 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5751 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5752 return resultobj;
5753 fail:
5754 return NULL;
5755 }
5756
5757
5758 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5759 PyObject *resultobj;
5760 wxRect result;
5761 char *kwnames[] = {
5762 NULL
5763 };
5764
5765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5766 {
5767 if (!wxPyCheckForApp()) SWIG_fail;
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 result = wxGetClientDisplayRect();
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 {
5775 wxRect * resultptr;
5776 resultptr = new wxRect((wxRect &)(result));
5777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5778 }
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj;
5787 wxCursor *arg1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 char *kwnames[] = {
5790 (char *) "cursor", NULL
5791 };
5792
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5794 {
5795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5796 if (SWIG_arg_fail(1)) SWIG_fail;
5797 if (arg1 == NULL) {
5798 SWIG_null_ref("wxCursor");
5799 }
5800 if (SWIG_arg_fail(1)) SWIG_fail;
5801 }
5802 {
5803 if (!wxPyCheckForApp()) SWIG_fail;
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 wxSetCursor(*arg1);
5806
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 Py_INCREF(Py_None); resultobj = Py_None;
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj;
5819 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5820 PyObject * obj0 = 0 ;
5821 char *kwnames[] = {
5822 (char *) "cursor", NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5826 if (obj0) {
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 }
5830 {
5831 if (!wxPyCheckForApp()) SWIG_fail;
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 wxBeginBusyCursor(arg1);
5834
5835 wxPyEndAllowThreads(__tstate);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 Py_INCREF(Py_None); resultobj = Py_None;
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxWindow *result;
5848 char *kwnames[] = {
5849 NULL
5850 };
5851
5852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5853 {
5854 if (!wxPyCheckForApp()) SWIG_fail;
5855 PyThreadState* __tstate = wxPyBeginAllowThreads();
5856 result = (wxWindow *)wxGetActiveWindow();
5857
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 {
5862 resultobj = wxPyMake_wxObject(result, 0);
5863 }
5864 return resultobj;
5865 fail:
5866 return NULL;
5867 }
5868
5869
5870 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5871 PyObject *resultobj;
5872 wxPoint *arg1 = 0 ;
5873 wxWindow *result;
5874 wxPoint temp1 ;
5875 PyObject * obj0 = 0 ;
5876 char *kwnames[] = {
5877 (char *) "pt", NULL
5878 };
5879
5880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5881 {
5882 arg1 = &temp1;
5883 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5884 }
5885 {
5886 if (!wxPyCheckForApp()) SWIG_fail;
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 {
5894 resultobj = wxPyMake_wxObject(result, 0);
5895 }
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj;
5904 wxPoint *arg1 = 0 ;
5905 wxWindow *result;
5906 wxPoint temp1 ;
5907 PyObject * obj0 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "pt", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5913 {
5914 arg1 = &temp1;
5915 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5916 }
5917 {
5918 if (!wxPyCheckForApp()) SWIG_fail;
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5921
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 {
5926 resultobj = wxPyMake_wxObject(result, 0);
5927 }
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj;
5936 wxWindow *arg1 = (wxWindow *) 0 ;
5937 wxWindow *result;
5938 PyObject * obj0 = 0 ;
5939 char *kwnames[] = {
5940 (char *) "win", NULL
5941 };
5942
5943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5945 if (SWIG_arg_fail(1)) SWIG_fail;
5946 {
5947 if (!wxPyCheckForApp()) SWIG_fail;
5948 PyThreadState* __tstate = wxPyBeginAllowThreads();
5949 result = (wxWindow *)wxGetTopLevelParent(arg1);
5950
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = wxPyMake_wxObject(result, 0);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj;
5965 wxKeyCode arg1 ;
5966 bool result;
5967 PyObject * obj0 = 0 ;
5968 char *kwnames[] = {
5969 (char *) "key", NULL
5970 };
5971
5972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5973 {
5974 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 }
5977 {
5978 if (!wxPyCheckForApp()) SWIG_fail;
5979 PyThreadState* __tstate = wxPyBeginAllowThreads();
5980 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5981
5982 wxPyEndAllowThreads(__tstate);
5983 if (PyErr_Occurred()) SWIG_fail;
5984 }
5985 {
5986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5987 }
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 char *kwnames[] = {
5997 NULL
5998 };
5999
6000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6001 {
6002 if (!wxPyCheckForApp()) SWIG_fail;
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 wxWakeUpMainThread();
6005
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 Py_INCREF(Py_None); resultobj = Py_None;
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj;
6018 char *kwnames[] = {
6019 NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6023 {
6024 if (!wxPyCheckForApp()) SWIG_fail;
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 wxMutexGuiEnter();
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 Py_INCREF(Py_None); resultobj = Py_None;
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 char *kwnames[] = {
6041 NULL
6042 };
6043
6044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6045 {
6046 if (!wxPyCheckForApp()) SWIG_fail;
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 wxMutexGuiLeave();
6049
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 Py_INCREF(Py_None); resultobj = Py_None;
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6061 PyObject *resultobj;
6062 wxMutexGuiLocker *result;
6063 char *kwnames[] = {
6064 NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6068 {
6069 if (!wxPyCheckForApp()) SWIG_fail;
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6086 PyObject * obj0 = 0 ;
6087 char *kwnames[] = {
6088 (char *) "self", NULL
6089 };
6090
6091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6093 if (SWIG_arg_fail(1)) SWIG_fail;
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 delete arg1;
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 Py_INCREF(Py_None); resultobj = Py_None;
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6109 PyObject *obj;
6110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6111 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6112 Py_INCREF(obj);
6113 return Py_BuildValue((char *)"");
6114 }
6115 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj;
6117 bool result;
6118 char *kwnames[] = {
6119 NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6123 {
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 result = (bool)wxThread_IsMain();
6126
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 {
6131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6132 }
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj;
6141 wxString *arg1 = 0 ;
6142 wxToolTip *result;
6143 bool temp1 = false ;
6144 PyObject * obj0 = 0 ;
6145 char *kwnames[] = {
6146 (char *) "tip", NULL
6147 };
6148
6149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6150 {
6151 arg1 = wxString_in_helper(obj0);
6152 if (arg1 == NULL) SWIG_fail;
6153 temp1 = true;
6154 }
6155 {
6156 if (!wxPyCheckForApp()) SWIG_fail;
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6159
6160 wxPyEndAllowThreads(__tstate);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 {
6164 resultobj = wxPyMake_wxObject(result, 1);
6165 }
6166 {
6167 if (temp1)
6168 delete arg1;
6169 }
6170 return resultobj;
6171 fail:
6172 {
6173 if (temp1)
6174 delete arg1;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxToolTip *arg1 = (wxToolTip *) 0 ;
6183 wxString *arg2 = 0 ;
6184 bool temp2 = false ;
6185 PyObject * obj0 = 0 ;
6186 PyObject * obj1 = 0 ;
6187 char *kwnames[] = {
6188 (char *) "self",(char *) "tip", NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6193 if (SWIG_arg_fail(1)) SWIG_fail;
6194 {
6195 arg2 = wxString_in_helper(obj1);
6196 if (arg2 == NULL) SWIG_fail;
6197 temp2 = true;
6198 }
6199 {
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 (arg1)->SetTip((wxString const &)*arg2);
6202
6203 wxPyEndAllowThreads(__tstate);
6204 if (PyErr_Occurred()) SWIG_fail;
6205 }
6206 Py_INCREF(Py_None); resultobj = Py_None;
6207 {
6208 if (temp2)
6209 delete arg2;
6210 }
6211 return resultobj;
6212 fail:
6213 {
6214 if (temp2)
6215 delete arg2;
6216 }
6217 return NULL;
6218 }
6219
6220
6221 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj;
6223 wxToolTip *arg1 = (wxToolTip *) 0 ;
6224 wxString result;
6225 PyObject * obj0 = 0 ;
6226 char *kwnames[] = {
6227 (char *) "self", NULL
6228 };
6229
6230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6232 if (SWIG_arg_fail(1)) SWIG_fail;
6233 {
6234 PyThreadState* __tstate = wxPyBeginAllowThreads();
6235 result = (arg1)->GetTip();
6236
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 {
6241 #if wxUSE_UNICODE
6242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6243 #else
6244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6245 #endif
6246 }
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 wxToolTip *arg1 = (wxToolTip *) 0 ;
6256 wxWindow *result;
6257 PyObject * obj0 = 0 ;
6258 char *kwnames[] = {
6259 (char *) "self", NULL
6260 };
6261
6262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6264 if (SWIG_arg_fail(1)) SWIG_fail;
6265 {
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 result = (wxWindow *)(arg1)->GetWindow();
6268
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 {
6273 resultobj = wxPyMake_wxObject(result, 0);
6274 }
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj;
6283 bool arg1 ;
6284 PyObject * obj0 = 0 ;
6285 char *kwnames[] = {
6286 (char *) "flag", NULL
6287 };
6288
6289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6290 {
6291 arg1 = (bool)(SWIG_As_bool(obj0));
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 }
6294 {
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 wxToolTip::Enable(arg1);
6297
6298 wxPyEndAllowThreads(__tstate);
6299 if (PyErr_Occurred()) SWIG_fail;
6300 }
6301 Py_INCREF(Py_None); resultobj = Py_None;
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 long arg1 ;
6311 PyObject * obj0 = 0 ;
6312 char *kwnames[] = {
6313 (char *) "milliseconds", NULL
6314 };
6315
6316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6317 {
6318 arg1 = (long)(SWIG_As_long(obj0));
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 }
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 wxToolTip::SetDelay(arg1);
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 Py_INCREF(Py_None); resultobj = Py_None;
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6336 PyObject *obj;
6337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6338 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6339 Py_INCREF(obj);
6340 return Py_BuildValue((char *)"");
6341 }
6342 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj;
6344 wxWindow *arg1 = (wxWindow *) 0 ;
6345 wxSize *arg2 = 0 ;
6346 wxCaret *result;
6347 wxSize temp2 ;
6348 PyObject * obj0 = 0 ;
6349 PyObject * obj1 = 0 ;
6350 char *kwnames[] = {
6351 (char *) "window",(char *) "size", NULL
6352 };
6353
6354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6356 if (SWIG_arg_fail(1)) SWIG_fail;
6357 {
6358 arg2 = &temp2;
6359 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6360 }
6361 {
6362 if (!wxPyCheckForApp()) SWIG_fail;
6363 PyThreadState* __tstate = wxPyBeginAllowThreads();
6364 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6365
6366 wxPyEndAllowThreads(__tstate);
6367 if (PyErr_Occurred()) SWIG_fail;
6368 }
6369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxCaret *arg1 = (wxCaret *) 0 ;
6379 PyObject * obj0 = 0 ;
6380 char *kwnames[] = {
6381 (char *) "self", NULL
6382 };
6383
6384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6386 if (SWIG_arg_fail(1)) SWIG_fail;
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 wxCaret_Destroy(arg1);
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 Py_INCREF(Py_None); resultobj = Py_None;
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxCaret *arg1 = (wxCaret *) 0 ;
6404 bool result;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (bool)(arg1)->IsOk();
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 {
6421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6422 }
6423 return resultobj;
6424 fail:
6425 return NULL;
6426 }
6427
6428
6429 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6430 PyObject *resultobj;
6431 wxCaret *arg1 = (wxCaret *) 0 ;
6432 bool result;
6433 PyObject * obj0 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "self", NULL
6436 };
6437
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6440 if (SWIG_arg_fail(1)) SWIG_fail;
6441 {
6442 PyThreadState* __tstate = wxPyBeginAllowThreads();
6443 result = (bool)(arg1)->IsVisible();
6444
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 {
6449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6450 }
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj;
6459 wxCaret *arg1 = (wxCaret *) 0 ;
6460 wxPoint result;
6461 PyObject * obj0 = 0 ;
6462 char *kwnames[] = {
6463 (char *) "self", NULL
6464 };
6465
6466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6468 if (SWIG_arg_fail(1)) SWIG_fail;
6469 {
6470 PyThreadState* __tstate = wxPyBeginAllowThreads();
6471 result = (arg1)->GetPosition();
6472
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 {
6477 wxPoint * resultptr;
6478 resultptr = new wxPoint((wxPoint &)(result));
6479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6480 }
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj;
6489 wxCaret *arg1 = (wxCaret *) 0 ;
6490 int *arg2 = (int *) 0 ;
6491 int *arg3 = (int *) 0 ;
6492 int temp2 ;
6493 int res2 = 0 ;
6494 int temp3 ;
6495 int res3 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "self", NULL
6499 };
6500
6501 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6502 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6505 if (SWIG_arg_fail(1)) SWIG_fail;
6506 {
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 (arg1)->GetPosition(arg2,arg3);
6509
6510 wxPyEndAllowThreads(__tstate);
6511 if (PyErr_Occurred()) SWIG_fail;
6512 }
6513 Py_INCREF(Py_None); resultobj = Py_None;
6514 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6515 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6516 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6517 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxCaret *arg1 = (wxCaret *) 0 ;
6527 wxSize result;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = (arg1)->GetSize();
6539
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 {
6544 wxSize * resultptr;
6545 resultptr = new wxSize((wxSize &)(result));
6546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6547 }
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj;
6556 wxCaret *arg1 = (wxCaret *) 0 ;
6557 int *arg2 = (int *) 0 ;
6558 int *arg3 = (int *) 0 ;
6559 int temp2 ;
6560 int res2 = 0 ;
6561 int temp3 ;
6562 int res3 = 0 ;
6563 PyObject * obj0 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self", NULL
6566 };
6567
6568 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6569 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6572 if (SWIG_arg_fail(1)) SWIG_fail;
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 (arg1)->GetSize(arg2,arg3);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 Py_INCREF(Py_None); resultobj = Py_None;
6581 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6582 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6583 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6584 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6592 PyObject *resultobj;
6593 wxCaret *arg1 = (wxCaret *) 0 ;
6594 wxWindow *result;
6595 PyObject * obj0 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self", NULL
6598 };
6599
6600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6602 if (SWIG_arg_fail(1)) SWIG_fail;
6603 {
6604 PyThreadState* __tstate = wxPyBeginAllowThreads();
6605 result = (wxWindow *)(arg1)->GetWindow();
6606
6607 wxPyEndAllowThreads(__tstate);
6608 if (PyErr_Occurred()) SWIG_fail;
6609 }
6610 {
6611 resultobj = wxPyMake_wxObject(result, 0);
6612 }
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxCaret *arg1 = (wxCaret *) 0 ;
6622 int arg2 ;
6623 int arg3 ;
6624 PyObject * obj0 = 0 ;
6625 PyObject * obj1 = 0 ;
6626 PyObject * obj2 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "self",(char *) "x",(char *) "y", NULL
6629 };
6630
6631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6633 if (SWIG_arg_fail(1)) SWIG_fail;
6634 {
6635 arg2 = (int)(SWIG_As_int(obj1));
6636 if (SWIG_arg_fail(2)) SWIG_fail;
6637 }
6638 {
6639 arg3 = (int)(SWIG_As_int(obj2));
6640 if (SWIG_arg_fail(3)) SWIG_fail;
6641 }
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 (arg1)->Move(arg2,arg3);
6645
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 Py_INCREF(Py_None); resultobj = Py_None;
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj;
6658 wxCaret *arg1 = (wxCaret *) 0 ;
6659 wxPoint *arg2 = 0 ;
6660 wxPoint temp2 ;
6661 PyObject * obj0 = 0 ;
6662 PyObject * obj1 = 0 ;
6663 char *kwnames[] = {
6664 (char *) "self",(char *) "pt", NULL
6665 };
6666
6667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6669 if (SWIG_arg_fail(1)) SWIG_fail;
6670 {
6671 arg2 = &temp2;
6672 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6673 }
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 (arg1)->Move((wxPoint const &)*arg2);
6677
6678 wxPyEndAllowThreads(__tstate);
6679 if (PyErr_Occurred()) SWIG_fail;
6680 }
6681 Py_INCREF(Py_None); resultobj = Py_None;
6682 return resultobj;
6683 fail:
6684 return NULL;
6685 }
6686
6687
6688 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6689 PyObject *resultobj;
6690 wxCaret *arg1 = (wxCaret *) 0 ;
6691 int arg2 ;
6692 int arg3 ;
6693 PyObject * obj0 = 0 ;
6694 PyObject * obj1 = 0 ;
6695 PyObject * obj2 = 0 ;
6696 char *kwnames[] = {
6697 (char *) "self",(char *) "width",(char *) "height", NULL
6698 };
6699
6700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(1)) SWIG_fail;
6703 {
6704 arg2 = (int)(SWIG_As_int(obj1));
6705 if (SWIG_arg_fail(2)) SWIG_fail;
6706 }
6707 {
6708 arg3 = (int)(SWIG_As_int(obj2));
6709 if (SWIG_arg_fail(3)) SWIG_fail;
6710 }
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 (arg1)->SetSize(arg2,arg3);
6714
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 Py_INCREF(Py_None); resultobj = Py_None;
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6726 PyObject *resultobj;
6727 wxCaret *arg1 = (wxCaret *) 0 ;
6728 wxSize *arg2 = 0 ;
6729 wxSize temp2 ;
6730 PyObject * obj0 = 0 ;
6731 PyObject * obj1 = 0 ;
6732 char *kwnames[] = {
6733 (char *) "self",(char *) "size", NULL
6734 };
6735
6736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6738 if (SWIG_arg_fail(1)) SWIG_fail;
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 (arg1)->SetSize((wxSize const &)*arg2);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 Py_INCREF(Py_None); resultobj = Py_None;
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj;
6759 wxCaret *arg1 = (wxCaret *) 0 ;
6760 int arg2 = (int) true ;
6761 PyObject * obj0 = 0 ;
6762 PyObject * obj1 = 0 ;
6763 char *kwnames[] = {
6764 (char *) "self",(char *) "show", NULL
6765 };
6766
6767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6769 if (SWIG_arg_fail(1)) SWIG_fail;
6770 if (obj1) {
6771 {
6772 arg2 = (int)(SWIG_As_int(obj1));
6773 if (SWIG_arg_fail(2)) SWIG_fail;
6774 }
6775 }
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 (arg1)->Show(arg2);
6779
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 Py_INCREF(Py_None); resultobj = Py_None;
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxCaret *arg1 = (wxCaret *) 0 ;
6793 PyObject * obj0 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 (arg1)->Hide();
6804
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 Py_INCREF(Py_None); resultobj = Py_None;
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6816 PyObject *resultobj;
6817 int result;
6818 char *kwnames[] = {
6819 NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (int)wxCaret::GetBlinkTime();
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 {
6831 resultobj = SWIG_From_int((int)(result));
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj;
6841 int arg1 ;
6842 PyObject * obj0 = 0 ;
6843 char *kwnames[] = {
6844 (char *) "milliseconds", NULL
6845 };
6846
6847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6848 {
6849 arg1 = (int)(SWIG_As_int(obj0));
6850 if (SWIG_arg_fail(1)) SWIG_fail;
6851 }
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 wxCaret::SetBlinkTime(arg1);
6855
6856 wxPyEndAllowThreads(__tstate);
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 Py_INCREF(Py_None); resultobj = Py_None;
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6867 PyObject *obj;
6868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6869 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6870 Py_INCREF(obj);
6871 return Py_BuildValue((char *)"");
6872 }
6873 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6874 PyObject *resultobj;
6875 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6876 wxBusyCursor *result;
6877 PyObject * obj0 = 0 ;
6878 char *kwnames[] = {
6879 (char *) "cursor", NULL
6880 };
6881
6882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6883 if (obj0) {
6884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6885 if (SWIG_arg_fail(1)) SWIG_fail;
6886 }
6887 {
6888 if (!wxPyCheckForApp()) SWIG_fail;
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6891
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6905 PyObject * obj0 = 0 ;
6906 char *kwnames[] = {
6907 (char *) "self", NULL
6908 };
6909
6910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6912 if (SWIG_arg_fail(1)) SWIG_fail;
6913 {
6914 PyThreadState* __tstate = wxPyBeginAllowThreads();
6915 delete arg1;
6916
6917 wxPyEndAllowThreads(__tstate);
6918 if (PyErr_Occurred()) SWIG_fail;
6919 }
6920 Py_INCREF(Py_None); resultobj = Py_None;
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6928 PyObject *obj;
6929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6930 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6931 Py_INCREF(obj);
6932 return Py_BuildValue((char *)"");
6933 }
6934 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6935 PyObject *resultobj;
6936 wxWindow *arg1 = (wxWindow *) NULL ;
6937 wxWindowDisabler *result;
6938 PyObject * obj0 = 0 ;
6939 char *kwnames[] = {
6940 (char *) "winToSkip", NULL
6941 };
6942
6943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6944 if (obj0) {
6945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 }
6948 {
6949 if (!wxPyCheckForApp()) SWIG_fail;
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6952
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6966 PyObject * obj0 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "self", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 delete arg1;
6977
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 Py_INCREF(Py_None); resultobj = Py_None;
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6989 PyObject *obj;
6990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6991 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6992 Py_INCREF(obj);
6993 return Py_BuildValue((char *)"");
6994 }
6995 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxString *arg1 = 0 ;
6998 wxBusyInfo *result;
6999 bool temp1 = false ;
7000 PyObject * obj0 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "message", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7006 {
7007 arg1 = wxString_in_helper(obj0);
7008 if (arg1 == NULL) SWIG_fail;
7009 temp1 = true;
7010 }
7011 {
7012 if (!wxPyCheckForApp()) SWIG_fail;
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7015
7016 wxPyEndAllowThreads(__tstate);
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7020 {
7021 if (temp1)
7022 delete arg1;
7023 }
7024 return resultobj;
7025 fail:
7026 {
7027 if (temp1)
7028 delete arg1;
7029 }
7030 return NULL;
7031 }
7032
7033
7034 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj;
7036 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7037 PyObject * obj0 = 0 ;
7038 char *kwnames[] = {
7039 (char *) "self", NULL
7040 };
7041
7042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7044 if (SWIG_arg_fail(1)) SWIG_fail;
7045 {
7046 PyThreadState* __tstate = wxPyBeginAllowThreads();
7047 delete arg1;
7048
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 Py_INCREF(Py_None); resultobj = Py_None;
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7060 PyObject *obj;
7061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7062 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7063 Py_INCREF(obj);
7064 return Py_BuildValue((char *)"");
7065 }
7066 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj;
7068 wxStopWatch *result;
7069 char *kwnames[] = {
7070 NULL
7071 };
7072
7073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7074 {
7075 PyThreadState* __tstate = wxPyBeginAllowThreads();
7076 result = (wxStopWatch *)new wxStopWatch();
7077
7078 wxPyEndAllowThreads(__tstate);
7079 if (PyErr_Occurred()) SWIG_fail;
7080 }
7081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7082 return resultobj;
7083 fail:
7084 return NULL;
7085 }
7086
7087
7088 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7089 PyObject *resultobj;
7090 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7091 long arg2 = (long) 0 ;
7092 PyObject * obj0 = 0 ;
7093 PyObject * obj1 = 0 ;
7094 char *kwnames[] = {
7095 (char *) "self",(char *) "t0", NULL
7096 };
7097
7098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 if (obj1) {
7102 {
7103 arg2 = (long)(SWIG_As_long(obj1));
7104 if (SWIG_arg_fail(2)) SWIG_fail;
7105 }
7106 }
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 (arg1)->Start(arg2);
7110
7111 wxPyEndAllowThreads(__tstate);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 Py_INCREF(Py_None); resultobj = Py_None;
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7124 PyObject * obj0 = 0 ;
7125 char *kwnames[] = {
7126 (char *) "self", NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7131 if (SWIG_arg_fail(1)) SWIG_fail;
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 (arg1)->Pause();
7135
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 Py_INCREF(Py_None); resultobj = Py_None;
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7149 PyObject * obj0 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 (arg1)->Resume();
7160
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 Py_INCREF(Py_None); resultobj = Py_None;
7165 return resultobj;
7166 fail:
7167 return NULL;
7168 }
7169
7170
7171 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7172 PyObject *resultobj;
7173 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7174 long result;
7175 PyObject * obj0 = 0 ;
7176 char *kwnames[] = {
7177 (char *) "self", NULL
7178 };
7179
7180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7182 if (SWIG_arg_fail(1)) SWIG_fail;
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 result = (long)((wxStopWatch const *)arg1)->Time();
7186
7187 wxPyEndAllowThreads(__tstate);
7188 if (PyErr_Occurred()) SWIG_fail;
7189 }
7190 {
7191 resultobj = SWIG_From_long((long)(result));
7192 }
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7200 PyObject *obj;
7201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7202 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7203 Py_INCREF(obj);
7204 return Py_BuildValue((char *)"");
7205 }
7206 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj;
7208 int arg1 = (int) 9 ;
7209 int arg2 = (int) wxID_FILE1 ;
7210 wxFileHistory *result;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "maxFiles",(char *) "idBase", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7218 if (obj0) {
7219 {
7220 arg1 = (int)(SWIG_As_int(obj0));
7221 if (SWIG_arg_fail(1)) SWIG_fail;
7222 }
7223 }
7224 if (obj1) {
7225 {
7226 arg2 = (int)(SWIG_As_int(obj1));
7227 if (SWIG_arg_fail(2)) SWIG_fail;
7228 }
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7247 PyObject * obj0 = 0 ;
7248 char *kwnames[] = {
7249 (char *) "self", NULL
7250 };
7251
7252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7254 if (SWIG_arg_fail(1)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 delete arg1;
7258
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 Py_INCREF(Py_None); resultobj = Py_None;
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj;
7271 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7272 wxString *arg2 = 0 ;
7273 bool temp2 = false ;
7274 PyObject * obj0 = 0 ;
7275 PyObject * obj1 = 0 ;
7276 char *kwnames[] = {
7277 (char *) "self",(char *) "file", NULL
7278 };
7279
7280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7282 if (SWIG_arg_fail(1)) SWIG_fail;
7283 {
7284 arg2 = wxString_in_helper(obj1);
7285 if (arg2 == NULL) SWIG_fail;
7286 temp2 = true;
7287 }
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 (arg1)->AddFileToHistory((wxString const &)*arg2);
7291
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 Py_INCREF(Py_None); resultobj = Py_None;
7296 {
7297 if (temp2)
7298 delete arg2;
7299 }
7300 return resultobj;
7301 fail:
7302 {
7303 if (temp2)
7304 delete arg2;
7305 }
7306 return NULL;
7307 }
7308
7309
7310 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj;
7312 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7313 int arg2 ;
7314 PyObject * obj0 = 0 ;
7315 PyObject * obj1 = 0 ;
7316 char *kwnames[] = {
7317 (char *) "self",(char *) "i", NULL
7318 };
7319
7320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7322 if (SWIG_arg_fail(1)) SWIG_fail;
7323 {
7324 arg2 = (int)(SWIG_As_int(obj1));
7325 if (SWIG_arg_fail(2)) SWIG_fail;
7326 }
7327 {
7328 PyThreadState* __tstate = wxPyBeginAllowThreads();
7329 (arg1)->RemoveFileFromHistory(arg2);
7330
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 Py_INCREF(Py_None); resultobj = Py_None;
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj;
7343 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7344 int result;
7345 PyObject * obj0 = 0 ;
7346 char *kwnames[] = {
7347 (char *) "self", NULL
7348 };
7349
7350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7352 if (SWIG_arg_fail(1)) SWIG_fail;
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 {
7361 resultobj = SWIG_From_int((int)(result));
7362 }
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7372 wxMenu *arg2 = (wxMenu *) 0 ;
7373 PyObject * obj0 = 0 ;
7374 PyObject * obj1 = 0 ;
7375 char *kwnames[] = {
7376 (char *) "self",(char *) "menu", NULL
7377 };
7378
7379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7381 if (SWIG_arg_fail(1)) SWIG_fail;
7382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7383 if (SWIG_arg_fail(2)) SWIG_fail;
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 (arg1)->UseMenu(arg2);
7387
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 Py_INCREF(Py_None); resultobj = Py_None;
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj;
7400 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7401 wxMenu *arg2 = (wxMenu *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 PyObject * obj1 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self",(char *) "menu", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7412 if (SWIG_arg_fail(2)) SWIG_fail;
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 (arg1)->RemoveMenu(arg2);
7416
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 Py_INCREF(Py_None); resultobj = Py_None;
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj;
7429 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7430 wxConfigBase *arg2 = 0 ;
7431 PyObject * obj0 = 0 ;
7432 PyObject * obj1 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self",(char *) "config", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7442 if (SWIG_arg_fail(2)) SWIG_fail;
7443 if (arg2 == NULL) {
7444 SWIG_null_ref("wxConfigBase");
7445 }
7446 if (SWIG_arg_fail(2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 (arg1)->Load(*arg2);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 Py_INCREF(Py_None); resultobj = Py_None;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj;
7464 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7465 wxConfigBase *arg2 = 0 ;
7466 PyObject * obj0 = 0 ;
7467 PyObject * obj1 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self",(char *) "config", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 {
7476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7477 if (SWIG_arg_fail(2)) SWIG_fail;
7478 if (arg2 == NULL) {
7479 SWIG_null_ref("wxConfigBase");
7480 }
7481 if (SWIG_arg_fail(2)) SWIG_fail;
7482 }
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 (arg1)->Save(*arg2);
7486
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 Py_INCREF(Py_None); resultobj = Py_None;
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7500 PyObject * obj0 = 0 ;
7501 char *kwnames[] = {
7502 (char *) "self", NULL
7503 };
7504
7505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7507 if (SWIG_arg_fail(1)) SWIG_fail;
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 (arg1)->AddFilesToMenu();
7511
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 Py_INCREF(Py_None); resultobj = Py_None;
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj;
7524 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7525 wxMenu *arg2 = (wxMenu *) 0 ;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "self",(char *) "menu", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(1)) SWIG_fail;
7535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7536 if (SWIG_arg_fail(2)) SWIG_fail;
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 (arg1)->AddFilesToMenu(arg2);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 Py_INCREF(Py_None); resultobj = Py_None;
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj;
7553 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7554 int arg2 ;
7555 wxString result;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 char *kwnames[] = {
7559 (char *) "self",(char *) "i", NULL
7560 };
7561
7562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7564 if (SWIG_arg_fail(1)) SWIG_fail;
7565 {
7566 arg2 = (int)(SWIG_As_int(obj1));
7567 if (SWIG_arg_fail(2)) SWIG_fail;
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 {
7577 #if wxUSE_UNICODE
7578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7579 #else
7580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7581 #endif
7582 }
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj;
7591 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7592 int result;
7593 PyObject * obj0 = 0 ;
7594 char *kwnames[] = {
7595 (char *) "self", NULL
7596 };
7597
7598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(1)) SWIG_fail;
7601 {
7602 PyThreadState* __tstate = wxPyBeginAllowThreads();
7603 result = (int)((wxFileHistory const *)arg1)->GetCount();
7604
7605 wxPyEndAllowThreads(__tstate);
7606 if (PyErr_Occurred()) SWIG_fail;
7607 }
7608 {
7609 resultobj = SWIG_From_int((int)(result));
7610 }
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7618 PyObject *obj;
7619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7620 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7621 Py_INCREF(obj);
7622 return Py_BuildValue((char *)"");
7623 }
7624 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj;
7626 wxString *arg1 = 0 ;
7627 wxString const &arg2_defvalue = wxPyEmptyString ;
7628 wxString *arg2 = (wxString *) &arg2_defvalue ;
7629 wxSingleInstanceChecker *result;
7630 bool temp1 = false ;
7631 bool temp2 = false ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char *kwnames[] = {
7635 (char *) "name",(char *) "path", NULL
7636 };
7637
7638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7639 {
7640 arg1 = wxString_in_helper(obj0);
7641 if (arg1 == NULL) SWIG_fail;
7642 temp1 = true;
7643 }
7644 if (obj1) {
7645 {
7646 arg2 = wxString_in_helper(obj1);
7647 if (arg2 == NULL) SWIG_fail;
7648 temp2 = true;
7649 }
7650 }
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7654
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7659 {
7660 if (temp1)
7661 delete arg1;
7662 }
7663 {
7664 if (temp2)
7665 delete arg2;
7666 }
7667 return resultobj;
7668 fail:
7669 {
7670 if (temp1)
7671 delete arg1;
7672 }
7673 {
7674 if (temp2)
7675 delete arg2;
7676 }
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxSingleInstanceChecker *result;
7684 char *kwnames[] = {
7685 NULL
7686 };
7687
7688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj;
7705 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7706 PyObject * obj0 = 0 ;
7707 char *kwnames[] = {
7708 (char *) "self", NULL
7709 };
7710
7711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7713 if (SWIG_arg_fail(1)) SWIG_fail;
7714 {
7715 PyThreadState* __tstate = wxPyBeginAllowThreads();
7716 delete arg1;
7717
7718 wxPyEndAllowThreads(__tstate);
7719 if (PyErr_Occurred()) SWIG_fail;
7720 }
7721 Py_INCREF(Py_None); resultobj = Py_None;
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7731 wxString *arg2 = 0 ;
7732 wxString const &arg3_defvalue = wxPyEmptyString ;
7733 wxString *arg3 = (wxString *) &arg3_defvalue ;
7734 bool result;
7735 bool temp2 = false ;
7736 bool temp3 = false ;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 PyObject * obj2 = 0 ;
7740 char *kwnames[] = {
7741 (char *) "self",(char *) "name",(char *) "path", NULL
7742 };
7743
7744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7746 if (SWIG_arg_fail(1)) SWIG_fail;
7747 {
7748 arg2 = wxString_in_helper(obj1);
7749 if (arg2 == NULL) SWIG_fail;
7750 temp2 = true;
7751 }
7752 if (obj2) {
7753 {
7754 arg3 = wxString_in_helper(obj2);
7755 if (arg3 == NULL) SWIG_fail;
7756 temp3 = true;
7757 }
7758 }
7759 {
7760 PyThreadState* __tstate = wxPyBeginAllowThreads();
7761 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7762
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7768 }
7769 {
7770 if (temp2)
7771 delete arg2;
7772 }
7773 {
7774 if (temp3)
7775 delete arg3;
7776 }
7777 return resultobj;
7778 fail:
7779 {
7780 if (temp2)
7781 delete arg2;
7782 }
7783 {
7784 if (temp3)
7785 delete arg3;
7786 }
7787 return NULL;
7788 }
7789
7790
7791 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj;
7793 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7794 bool result;
7795 PyObject * obj0 = 0 ;
7796 char *kwnames[] = {
7797 (char *) "self", NULL
7798 };
7799
7800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7802 if (SWIG_arg_fail(1)) SWIG_fail;
7803 {
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7806
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 {
7811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7812 }
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7820 PyObject *obj;
7821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7822 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7823 Py_INCREF(obj);
7824 return Py_BuildValue((char *)"");
7825 }
7826 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj;
7828 wxWindow *arg1 = (wxWindow *) 0 ;
7829 wxDC *arg2 = 0 ;
7830 bool result;
7831 PyObject * obj0 = 0 ;
7832 PyObject * obj1 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "window",(char *) "dc", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7842 if (SWIG_arg_fail(2)) SWIG_fail;
7843 if (arg2 == NULL) {
7844 SWIG_null_ref("wxDC");
7845 }
7846 if (SWIG_arg_fail(2)) SWIG_fail;
7847 }
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7851
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 {
7856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7857 }
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj;
7866 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7867 PyObject * obj0 = 0 ;
7868 char *kwnames[] = {
7869 (char *) "self", NULL
7870 };
7871
7872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7874 if (SWIG_arg_fail(1)) SWIG_fail;
7875 {
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 delete arg1;
7878
7879 wxPyEndAllowThreads(__tstate);
7880 if (PyErr_Occurred()) SWIG_fail;
7881 }
7882 Py_INCREF(Py_None); resultobj = Py_None;
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7890 PyObject *resultobj;
7891 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7892 wxString result;
7893 PyObject * obj0 = 0 ;
7894 char *kwnames[] = {
7895 (char *) "self", NULL
7896 };
7897
7898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7900 if (SWIG_arg_fail(1)) SWIG_fail;
7901 {
7902 PyThreadState* __tstate = wxPyBeginAllowThreads();
7903 result = (arg1)->GetTip();
7904
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 {
7909 #if wxUSE_UNICODE
7910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7911 #else
7912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7913 #endif
7914 }
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj;
7923 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7924 size_t result;
7925 PyObject * obj0 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (size_t)(arg1)->GetCurrentTip();
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj;
7951 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7952 wxString *arg2 = 0 ;
7953 wxString result;
7954 bool temp2 = false ;
7955 PyObject * obj0 = 0 ;
7956 PyObject * obj1 = 0 ;
7957 char *kwnames[] = {
7958 (char *) "self",(char *) "tip", NULL
7959 };
7960
7961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7963 if (SWIG_arg_fail(1)) SWIG_fail;
7964 {
7965 arg2 = wxString_in_helper(obj1);
7966 if (arg2 == NULL) SWIG_fail;
7967 temp2 = true;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 #if wxUSE_UNICODE
7978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7979 #else
7980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7981 #endif
7982 }
7983 {
7984 if (temp2)
7985 delete arg2;
7986 }
7987 return resultobj;
7988 fail:
7989 {
7990 if (temp2)
7991 delete arg2;
7992 }
7993 return NULL;
7994 }
7995
7996
7997 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7998 PyObject *obj;
7999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8000 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8001 Py_INCREF(obj);
8002 return Py_BuildValue((char *)"");
8003 }
8004 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8005 PyObject *resultobj;
8006 size_t arg1 ;
8007 wxPyTipProvider *result;
8008 PyObject * obj0 = 0 ;
8009 char *kwnames[] = {
8010 (char *) "currentTip", NULL
8011 };
8012
8013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8014 {
8015 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8016 if (SWIG_arg_fail(1)) SWIG_fail;
8017 }
8018 {
8019 PyThreadState* __tstate = wxPyBeginAllowThreads();
8020 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8021
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj;
8034 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8035 PyObject *arg2 = (PyObject *) 0 ;
8036 PyObject *arg3 = (PyObject *) 0 ;
8037 PyObject * obj0 = 0 ;
8038 PyObject * obj1 = 0 ;
8039 PyObject * obj2 = 0 ;
8040 char *kwnames[] = {
8041 (char *) "self",(char *) "self",(char *) "_class", NULL
8042 };
8043
8044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8046 if (SWIG_arg_fail(1)) SWIG_fail;
8047 arg2 = obj1;
8048 arg3 = obj2;
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 (arg1)->_setCallbackInfo(arg2,arg3);
8052
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 Py_INCREF(Py_None); resultobj = Py_None;
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8064 PyObject *obj;
8065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8066 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8067 Py_INCREF(obj);
8068 return Py_BuildValue((char *)"");
8069 }
8070 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj;
8072 wxWindow *arg1 = (wxWindow *) 0 ;
8073 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8074 bool arg3 = (bool) true ;
8075 bool result;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 PyObject * obj2 = 0 ;
8079 char *kwnames[] = {
8080 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8081 };
8082
8083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(1)) SWIG_fail;
8086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(2)) SWIG_fail;
8088 if (obj2) {
8089 {
8090 arg3 = (bool)(SWIG_As_bool(obj2));
8091 if (SWIG_arg_fail(3)) SWIG_fail;
8092 }
8093 }
8094 {
8095 if (!wxPyCheckForApp()) SWIG_fail;
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 result = (bool)wxShowTip(arg1,arg2,arg3);
8098
8099 wxPyEndAllowThreads(__tstate);
8100 if (PyErr_Occurred()) SWIG_fail;
8101 }
8102 {
8103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8104 }
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj;
8113 wxString *arg1 = 0 ;
8114 size_t arg2 ;
8115 wxTipProvider *result;
8116 bool temp1 = false ;
8117 PyObject * obj0 = 0 ;
8118 PyObject * obj1 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "filename",(char *) "currentTip", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8124 {
8125 arg1 = wxString_in_helper(obj0);
8126 if (arg1 == NULL) SWIG_fail;
8127 temp1 = true;
8128 }
8129 {
8130 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8131 if (SWIG_arg_fail(2)) SWIG_fail;
8132 }
8133 {
8134 if (!wxPyCheckForApp()) SWIG_fail;
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8142 {
8143 if (temp1)
8144 delete arg1;
8145 }
8146 return resultobj;
8147 fail:
8148 {
8149 if (temp1)
8150 delete arg1;
8151 }
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8159 int arg2 = (int) -1 ;
8160 wxPyTimer *result;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "owner",(char *) "id", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8168 if (obj0) {
8169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8170 if (SWIG_arg_fail(1)) SWIG_fail;
8171 }
8172 if (obj1) {
8173 {
8174 arg2 = (int)(SWIG_As_int(obj1));
8175 if (SWIG_arg_fail(2)) SWIG_fail;
8176 }
8177 }
8178 {
8179 if (!wxPyCheckForApp()) SWIG_fail;
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8182
8183 wxPyEndAllowThreads(__tstate);
8184 if (PyErr_Occurred()) SWIG_fail;
8185 }
8186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8187 return resultobj;
8188 fail:
8189 return NULL;
8190 }
8191
8192
8193 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj;
8195 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8196 PyObject * obj0 = 0 ;
8197 char *kwnames[] = {
8198 (char *) "self", NULL
8199 };
8200
8201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8203 if (SWIG_arg_fail(1)) SWIG_fail;
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 delete arg1;
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 Py_INCREF(Py_None); resultobj = Py_None;
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8219 PyObject *resultobj;
8220 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8221 PyObject *arg2 = (PyObject *) 0 ;
8222 PyObject *arg3 = (PyObject *) 0 ;
8223 int arg4 = (int) 1 ;
8224 PyObject * obj0 = 0 ;
8225 PyObject * obj1 = 0 ;
8226 PyObject * obj2 = 0 ;
8227 PyObject * obj3 = 0 ;
8228 char *kwnames[] = {
8229 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8230 };
8231
8232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8234 if (SWIG_arg_fail(1)) SWIG_fail;
8235 arg2 = obj1;
8236 arg3 = obj2;
8237 if (obj3) {
8238 {
8239 arg4 = (int)(SWIG_As_int(obj3));
8240 if (SWIG_arg_fail(4)) SWIG_fail;
8241 }
8242 }
8243 {
8244 PyThreadState* __tstate = wxPyBeginAllowThreads();
8245 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8246
8247 wxPyEndAllowThreads(__tstate);
8248 if (PyErr_Occurred()) SWIG_fail;
8249 }
8250 Py_INCREF(Py_None); resultobj = Py_None;
8251 return resultobj;
8252 fail:
8253 return NULL;
8254 }
8255
8256
8257 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj;
8259 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8260 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8261 int arg3 = (int) -1 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 PyObject * obj2 = 0 ;
8265 char *kwnames[] = {
8266 (char *) "self",(char *) "owner",(char *) "id", NULL
8267 };
8268
8269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8271 if (SWIG_arg_fail(1)) SWIG_fail;
8272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8273 if (SWIG_arg_fail(2)) SWIG_fail;
8274 if (obj2) {
8275 {
8276 arg3 = (int)(SWIG_As_int(obj2));
8277 if (SWIG_arg_fail(3)) SWIG_fail;
8278 }
8279 }
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 (arg1)->SetOwner(arg2,arg3);
8283
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 Py_INCREF(Py_None); resultobj = Py_None;
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj;
8296 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8297 wxEvtHandler *result;
8298 PyObject * obj0 = 0 ;
8299 char *kwnames[] = {
8300 (char *) "self", NULL
8301 };
8302
8303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8305 if (SWIG_arg_fail(1)) SWIG_fail;
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = (wxEvtHandler *)(arg1)->GetOwner();
8309
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 {
8314 resultobj = wxPyMake_wxObject(result, 0);
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj;
8324 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8325 int arg2 = (int) -1 ;
8326 bool arg3 = (bool) false ;
8327 bool result;
8328 PyObject * obj0 = 0 ;
8329 PyObject * obj1 = 0 ;
8330 PyObject * obj2 = 0 ;
8331 char *kwnames[] = {
8332 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8333 };
8334
8335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(1)) SWIG_fail;
8338 if (obj1) {
8339 {
8340 arg2 = (int)(SWIG_As_int(obj1));
8341 if (SWIG_arg_fail(2)) SWIG_fail;
8342 }
8343 }
8344 if (obj2) {
8345 {
8346 arg3 = (bool)(SWIG_As_bool(obj2));
8347 if (SWIG_arg_fail(3)) SWIG_fail;
8348 }
8349 }
8350 {
8351 PyThreadState* __tstate = wxPyBeginAllowThreads();
8352 result = (bool)(arg1)->Start(arg2,arg3);
8353
8354 wxPyEndAllowThreads(__tstate);
8355 if (PyErr_Occurred()) SWIG_fail;
8356 }
8357 {
8358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8359 }
8360 return resultobj;
8361 fail:
8362 return NULL;
8363 }
8364
8365
8366 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8367 PyObject *resultobj;
8368 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8369 PyObject * obj0 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "self", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 (arg1)->Stop();
8380
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 Py_INCREF(Py_None); resultobj = Py_None;
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj;
8393 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8394 bool result;
8395 PyObject * obj0 = 0 ;
8396 char *kwnames[] = {
8397 (char *) "self", NULL
8398 };
8399
8400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8402 if (SWIG_arg_fail(1)) SWIG_fail;
8403 {
8404 PyThreadState* __tstate = wxPyBeginAllowThreads();
8405 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8406
8407 wxPyEndAllowThreads(__tstate);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 {
8411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8412 }
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj;
8421 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8422 int result;
8423 PyObject * obj0 = 0 ;
8424 char *kwnames[] = {
8425 (char *) "self", NULL
8426 };
8427
8428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8430 if (SWIG_arg_fail(1)) SWIG_fail;
8431 {
8432 PyThreadState* __tstate = wxPyBeginAllowThreads();
8433 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8434
8435 wxPyEndAllowThreads(__tstate);
8436 if (PyErr_Occurred()) SWIG_fail;
8437 }
8438 {
8439 resultobj = SWIG_From_int((int)(result));
8440 }
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8450 bool result;
8451 PyObject * obj0 = 0 ;
8452 char *kwnames[] = {
8453 (char *) "self", NULL
8454 };
8455
8456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 {
8467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8468 }
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8478 int result;
8479 PyObject * obj0 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (int)((wxPyTimer const *)arg1)->GetId();
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 resultobj = SWIG_From_int((int)(result));
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8504 PyObject *obj;
8505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8506 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8507 Py_INCREF(obj);
8508 return Py_BuildValue((char *)"");
8509 }
8510 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj;
8512 int arg1 = (int) 0 ;
8513 int arg2 = (int) 0 ;
8514 wxTimerEvent *result;
8515 PyObject * obj0 = 0 ;
8516 PyObject * obj1 = 0 ;
8517 char *kwnames[] = {
8518 (char *) "timerid",(char *) "interval", NULL
8519 };
8520
8521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8522 if (obj0) {
8523 {
8524 arg1 = (int)(SWIG_As_int(obj0));
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 }
8527 }
8528 if (obj1) {
8529 {
8530 arg2 = (int)(SWIG_As_int(obj1));
8531 if (SWIG_arg_fail(2)) SWIG_fail;
8532 }
8533 }
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8537
8538 wxPyEndAllowThreads(__tstate);
8539 if (PyErr_Occurred()) SWIG_fail;
8540 }
8541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8542 return resultobj;
8543 fail:
8544 return NULL;
8545 }
8546
8547
8548 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj;
8550 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8551 int result;
8552 PyObject * obj0 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8563
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 {
8568 resultobj = SWIG_From_int((int)(result));
8569 }
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8577 PyObject *obj;
8578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8579 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8580 Py_INCREF(obj);
8581 return Py_BuildValue((char *)"");
8582 }
8583 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8584 PyObject *resultobj;
8585 wxTimer *arg1 = 0 ;
8586 wxTimerRunner *result;
8587 PyObject * obj0 = 0 ;
8588
8589 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8590 {
8591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 if (arg1 == NULL) {
8594 SWIG_null_ref("wxTimer");
8595 }
8596 if (SWIG_arg_fail(1)) SWIG_fail;
8597 }
8598 {
8599 if (!wxPyCheckForApp()) SWIG_fail;
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8602
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8614 PyObject *resultobj;
8615 wxTimer *arg1 = 0 ;
8616 int arg2 ;
8617 bool arg3 = (bool) false ;
8618 wxTimerRunner *result;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 PyObject * obj2 = 0 ;
8622
8623 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8624 {
8625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8626 if (SWIG_arg_fail(1)) SWIG_fail;
8627 if (arg1 == NULL) {
8628 SWIG_null_ref("wxTimer");
8629 }
8630 if (SWIG_arg_fail(1)) SWIG_fail;
8631 }
8632 {
8633 arg2 = (int)(SWIG_As_int(obj1));
8634 if (SWIG_arg_fail(2)) SWIG_fail;
8635 }
8636 if (obj2) {
8637 {
8638 arg3 = (bool)(SWIG_As_bool(obj2));
8639 if (SWIG_arg_fail(3)) SWIG_fail;
8640 }
8641 }
8642 {
8643 if (!wxPyCheckForApp()) SWIG_fail;
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8646
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8658 int argc;
8659 PyObject *argv[4];
8660 int ii;
8661
8662 argc = PyObject_Length(args);
8663 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8664 argv[ii] = PyTuple_GetItem(args,ii);
8665 }
8666 if (argc == 1) {
8667 int _v;
8668 {
8669 void *ptr = 0;
8670 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8671 _v = 0;
8672 PyErr_Clear();
8673 } else {
8674 _v = (ptr != 0);
8675 }
8676 }
8677 if (_v) {
8678 return _wrap_new_TimerRunner__SWIG_0(self,args);
8679 }
8680 }
8681 if ((argc >= 2) && (argc <= 3)) {
8682 int _v;
8683 {
8684 void *ptr = 0;
8685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8686 _v = 0;
8687 PyErr_Clear();
8688 } else {
8689 _v = (ptr != 0);
8690 }
8691 }
8692 if (_v) {
8693 _v = SWIG_Check_int(argv[1]);
8694 if (_v) {
8695 if (argc <= 2) {
8696 return _wrap_new_TimerRunner__SWIG_1(self,args);
8697 }
8698 _v = SWIG_Check_bool(argv[2]);
8699 if (_v) {
8700 return _wrap_new_TimerRunner__SWIG_1(self,args);
8701 }
8702 }
8703 }
8704 }
8705
8706 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8707 return NULL;
8708 }
8709
8710
8711 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8712 PyObject *resultobj;
8713 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8714 PyObject * obj0 = 0 ;
8715 char *kwnames[] = {
8716 (char *) "self", NULL
8717 };
8718
8719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8721 if (SWIG_arg_fail(1)) SWIG_fail;
8722 {
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 delete arg1;
8725
8726 wxPyEndAllowThreads(__tstate);
8727 if (PyErr_Occurred()) SWIG_fail;
8728 }
8729 Py_INCREF(Py_None); resultobj = Py_None;
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8739 int arg2 ;
8740 bool arg3 = (bool) false ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 PyObject * obj2 = 0 ;
8744 char *kwnames[] = {
8745 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8746 };
8747
8748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8750 if (SWIG_arg_fail(1)) SWIG_fail;
8751 {
8752 arg2 = (int)(SWIG_As_int(obj1));
8753 if (SWIG_arg_fail(2)) SWIG_fail;
8754 }
8755 if (obj2) {
8756 {
8757 arg3 = (bool)(SWIG_As_bool(obj2));
8758 if (SWIG_arg_fail(3)) SWIG_fail;
8759 }
8760 }
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 (arg1)->Start(arg2,arg3);
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 return resultobj;
8770 fail:
8771 return NULL;
8772 }
8773
8774
8775 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8776 PyObject *obj;
8777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8778 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8779 Py_INCREF(obj);
8780 return Py_BuildValue((char *)"");
8781 }
8782 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxLog *result;
8785 char *kwnames[] = {
8786 NULL
8787 };
8788
8789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 result = (wxLog *)new wxLog();
8793
8794 wxPyEndAllowThreads(__tstate);
8795 if (PyErr_Occurred()) SWIG_fail;
8796 }
8797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 bool result;
8807 char *kwnames[] = {
8808 NULL
8809 };
8810
8811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 result = (bool)wxLog::IsEnabled();
8815
8816 wxPyEndAllowThreads(__tstate);
8817 if (PyErr_Occurred()) SWIG_fail;
8818 }
8819 {
8820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8821 }
8822 return resultobj;
8823 fail:
8824 return NULL;
8825 }
8826
8827
8828 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8829 PyObject *resultobj;
8830 bool arg1 = (bool) true ;
8831 bool result;
8832 PyObject * obj0 = 0 ;
8833 char *kwnames[] = {
8834 (char *) "doIt", NULL
8835 };
8836
8837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8838 if (obj0) {
8839 {
8840 arg1 = (bool)(SWIG_As_bool(obj0));
8841 if (SWIG_arg_fail(1)) SWIG_fail;
8842 }
8843 }
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 result = (bool)wxLog::EnableLogging(arg1);
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 {
8852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8853 }
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj;
8862 wxLogLevel arg1 ;
8863 wxChar *arg2 = (wxChar *) 0 ;
8864 time_t arg3 ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 PyObject * obj2 = 0 ;
8868 char *kwnames[] = {
8869 (char *) "level",(char *) "szString",(char *) "t", NULL
8870 };
8871
8872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8873 {
8874 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8875 if (SWIG_arg_fail(1)) SWIG_fail;
8876 }
8877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8878 if (SWIG_arg_fail(2)) SWIG_fail;
8879 {
8880 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8881 if (SWIG_arg_fail(3)) SWIG_fail;
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 Py_INCREF(Py_None); resultobj = Py_None;
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj;
8899 wxLog *arg1 = (wxLog *) 0 ;
8900 PyObject * obj0 = 0 ;
8901 char *kwnames[] = {
8902 (char *) "self", NULL
8903 };
8904
8905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8907 if (SWIG_arg_fail(1)) SWIG_fail;
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 (arg1)->Flush();
8911
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 Py_INCREF(Py_None); resultobj = Py_None;
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj;
8924 char *kwnames[] = {
8925 NULL
8926 };
8927
8928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 wxLog::FlushActive();
8932
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 Py_INCREF(Py_None); resultobj = Py_None;
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj;
8945 wxLog *result;
8946 char *kwnames[] = {
8947 NULL
8948 };
8949
8950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = (wxLog *)wxLog::GetActiveTarget();
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj;
8967 wxLog *arg1 = (wxLog *) 0 ;
8968 wxLog *result;
8969 PyObject * obj0 = 0 ;
8970 char *kwnames[] = {
8971 (char *) "pLogger", NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8976 if (SWIG_arg_fail(1)) SWIG_fail;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8980
8981 wxPyEndAllowThreads(__tstate);
8982 if (PyErr_Occurred()) SWIG_fail;
8983 }
8984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj;
8993 char *kwnames[] = {
8994 NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8998 {
8999 PyThreadState* __tstate = wxPyBeginAllowThreads();
9000 wxLog::Suspend();
9001
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 Py_INCREF(Py_None); resultobj = Py_None;
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9013 PyObject *resultobj;
9014 char *kwnames[] = {
9015 NULL
9016 };
9017
9018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 wxLog::Resume();
9022
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 Py_INCREF(Py_None); resultobj = Py_None;
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 bool arg1 = (bool) true ;
9036 PyObject * obj0 = 0 ;
9037 char *kwnames[] = {
9038 (char *) "bVerbose", NULL
9039 };
9040
9041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9042 if (obj0) {
9043 {
9044 arg1 = (bool)(SWIG_As_bool(obj0));
9045 if (SWIG_arg_fail(1)) SWIG_fail;
9046 }
9047 }
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxLog::SetVerbose(arg1);
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxLogLevel arg1 ;
9065 PyObject * obj0 = 0 ;
9066 char *kwnames[] = {
9067 (char *) "logLevel", NULL
9068 };
9069
9070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9071 {
9072 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9073 if (SWIG_arg_fail(1)) SWIG_fail;
9074 }
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 wxLog::SetLogLevel(arg1);
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 Py_INCREF(Py_None); resultobj = Py_None;
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 char *kwnames[] = {
9092 NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 wxLog::DontCreateOnDemand();
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 Py_INCREF(Py_None); resultobj = Py_None;
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxTraceMask arg1 ;
9113 PyObject * obj0 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "ulMask", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9119 {
9120 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9121 if (SWIG_arg_fail(1)) SWIG_fail;
9122 }
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 wxLog::SetTraceMask(arg1);
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 Py_INCREF(Py_None); resultobj = Py_None;
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxString *arg1 = 0 ;
9140 bool temp1 = false ;
9141 PyObject * obj0 = 0 ;
9142 char *kwnames[] = {
9143 (char *) "str", NULL
9144 };
9145
9146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9147 {
9148 arg1 = wxString_in_helper(obj0);
9149 if (arg1 == NULL) SWIG_fail;
9150 temp1 = true;
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 wxLog::AddTraceMask((wxString const &)*arg1);
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 Py_INCREF(Py_None); resultobj = Py_None;
9160 {
9161 if (temp1)
9162 delete arg1;
9163 }
9164 return resultobj;
9165 fail:
9166 {
9167 if (temp1)
9168 delete arg1;
9169 }
9170 return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj;
9176 wxString *arg1 = 0 ;
9177 bool temp1 = false ;
9178 PyObject * obj0 = 0 ;
9179 char *kwnames[] = {
9180 (char *) "str", NULL
9181 };
9182
9183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9184 {
9185 arg1 = wxString_in_helper(obj0);
9186 if (arg1 == NULL) SWIG_fail;
9187 temp1 = true;
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 wxLog::RemoveTraceMask((wxString const &)*arg1);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 Py_INCREF(Py_None); resultobj = Py_None;
9197 {
9198 if (temp1)
9199 delete arg1;
9200 }
9201 return resultobj;
9202 fail:
9203 {
9204 if (temp1)
9205 delete arg1;
9206 }
9207 return NULL;
9208 }
9209
9210
9211 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 char *kwnames[] = {
9214 NULL
9215 };
9216
9217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9218 {
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 wxLog::ClearTraceMasks();
9221
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 Py_INCREF(Py_None); resultobj = Py_None;
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9233 PyObject *resultobj;
9234 wxArrayString *result;
9235 char *kwnames[] = {
9236 NULL
9237 };
9238
9239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 {
9243 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9244 result = (wxArrayString *) &_result_ref;
9245 }
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = wxArrayString2PyList_helper(*result);
9252 }
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 wxChar *arg1 = (wxChar *) 0 ;
9262 PyObject * obj0 = 0 ;
9263 char *kwnames[] = {
9264 (char *) "ts", NULL
9265 };
9266
9267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9269 if (SWIG_arg_fail(1)) SWIG_fail;
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 wxLog::SetTimestamp((wxChar const *)arg1);
9273
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 Py_INCREF(Py_None); resultobj = Py_None;
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj;
9286 bool result;
9287 char *kwnames[] = {
9288 NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (bool)wxLog::GetVerbose();
9295
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 {
9300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9301 }
9302 return resultobj;
9303 fail:
9304 return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9309 PyObject *resultobj;
9310 wxTraceMask result;
9311 char *kwnames[] = {
9312 NULL
9313 };
9314
9315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (wxTraceMask)wxLog::GetTraceMask();
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 {
9324 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9325 }
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9333 PyObject *resultobj;
9334 wxChar *arg1 = (wxChar *) 0 ;
9335 bool result;
9336 PyObject * obj0 = 0 ;
9337 char *kwnames[] = {
9338 (char *) "mask", NULL
9339 };
9340
9341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9343 if (SWIG_arg_fail(1)) SWIG_fail;
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9347
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 {
9352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9353 }
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxLogLevel result;
9363 char *kwnames[] = {
9364 NULL
9365 };
9366
9367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 result = (wxLogLevel)wxLog::GetLogLevel();
9371
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 {
9376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9377 }
9378 return resultobj;
9379 fail:
9380 return NULL;
9381 }
9382
9383
9384 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9385 PyObject *resultobj;
9386 wxChar *result;
9387 char *kwnames[] = {
9388 NULL
9389 };
9390
9391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 result = (wxChar *)wxLog::GetTimestamp();
9395
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 wxString result;
9409 char *kwnames[] = {
9410 NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = Log_TimeStamp();
9417
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 #if wxUSE_UNICODE
9423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9424 #else
9425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9426 #endif
9427 }
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxLog *arg1 = (wxLog *) 0 ;
9437 PyObject * obj0 = 0 ;
9438 char *kwnames[] = {
9439 (char *) "self", NULL
9440 };
9441
9442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9444 if (SWIG_arg_fail(1)) SWIG_fail;
9445 {
9446 PyThreadState* __tstate = wxPyBeginAllowThreads();
9447 wxLog_Destroy(arg1);
9448
9449 wxPyEndAllowThreads(__tstate);
9450 if (PyErr_Occurred()) SWIG_fail;
9451 }
9452 Py_INCREF(Py_None); resultobj = Py_None;
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9460 PyObject *obj;
9461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9462 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9463 Py_INCREF(obj);
9464 return Py_BuildValue((char *)"");
9465 }
9466 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9467 PyObject *resultobj;
9468 wxLogStderr *result;
9469 char *kwnames[] = {
9470 NULL
9471 };
9472
9473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (wxLogStderr *)new wxLogStderr();
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9489 PyObject *obj;
9490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9491 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9492 Py_INCREF(obj);
9493 return Py_BuildValue((char *)"");
9494 }
9495 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9498 wxLogTextCtrl *result;
9499 PyObject * obj0 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "pTextCtrl", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9506 if (SWIG_arg_fail(1)) SWIG_fail;
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9522 PyObject *obj;
9523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9524 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9525 Py_INCREF(obj);
9526 return Py_BuildValue((char *)"");
9527 }
9528 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9529 PyObject *resultobj;
9530 wxLogGui *result;
9531 char *kwnames[] = {
9532 NULL
9533 };
9534
9535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (wxLogGui *)new wxLogGui();
9539
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9551 PyObject *obj;
9552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9553 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9554 Py_INCREF(obj);
9555 return Py_BuildValue((char *)"");
9556 }
9557 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj;
9559 wxFrame *arg1 = (wxFrame *) 0 ;
9560 wxString *arg2 = 0 ;
9561 bool arg3 = (bool) true ;
9562 bool arg4 = (bool) true ;
9563 wxLogWindow *result;
9564 bool temp2 = false ;
9565 PyObject * obj0 = 0 ;
9566 PyObject * obj1 = 0 ;
9567 PyObject * obj2 = 0 ;
9568 PyObject * obj3 = 0 ;
9569 char *kwnames[] = {
9570 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9571 };
9572
9573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9575 if (SWIG_arg_fail(1)) SWIG_fail;
9576 {
9577 arg2 = wxString_in_helper(obj1);
9578 if (arg2 == NULL) SWIG_fail;
9579 temp2 = true;
9580 }
9581 if (obj2) {
9582 {
9583 arg3 = (bool)(SWIG_As_bool(obj2));
9584 if (SWIG_arg_fail(3)) SWIG_fail;
9585 }
9586 }
9587 if (obj3) {
9588 {
9589 arg4 = (bool)(SWIG_As_bool(obj3));
9590 if (SWIG_arg_fail(4)) SWIG_fail;
9591 }
9592 }
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9596
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9601 {
9602 if (temp2)
9603 delete arg2;
9604 }
9605 return resultobj;
9606 fail:
9607 {
9608 if (temp2)
9609 delete arg2;
9610 }
9611 return NULL;
9612 }
9613
9614
9615 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9616 PyObject *resultobj;
9617 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9618 bool arg2 = (bool) true ;
9619 PyObject * obj0 = 0 ;
9620 PyObject * obj1 = 0 ;
9621 char *kwnames[] = {
9622 (char *) "self",(char *) "bShow", NULL
9623 };
9624
9625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9627 if (SWIG_arg_fail(1)) SWIG_fail;
9628 if (obj1) {
9629 {
9630 arg2 = (bool)(SWIG_As_bool(obj1));
9631 if (SWIG_arg_fail(2)) SWIG_fail;
9632 }
9633 }
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 (arg1)->Show(arg2);
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 Py_INCREF(Py_None); resultobj = Py_None;
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9649 PyObject *resultobj;
9650 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9651 wxFrame *result;
9652 PyObject * obj0 = 0 ;
9653 char *kwnames[] = {
9654 (char *) "self", NULL
9655 };
9656
9657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9659 if (SWIG_arg_fail(1)) SWIG_fail;
9660 {
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9663
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 {
9668 resultobj = wxPyMake_wxObject(result, 0);
9669 }
9670 return resultobj;
9671 fail:
9672 return NULL;
9673 }
9674
9675
9676 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9677 PyObject *resultobj;
9678 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9679 wxLog *result;
9680 PyObject * obj0 = 0 ;
9681 char *kwnames[] = {
9682 (char *) "self", NULL
9683 };
9684
9685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9687 if (SWIG_arg_fail(1)) SWIG_fail;
9688 {
9689 PyThreadState* __tstate = wxPyBeginAllowThreads();
9690 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9691
9692 wxPyEndAllowThreads(__tstate);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj;
9704 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9705 bool result;
9706 PyObject * obj0 = 0 ;
9707 char *kwnames[] = {
9708 (char *) "self", NULL
9709 };
9710
9711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9713 if (SWIG_arg_fail(1)) SWIG_fail;
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9723 }
9724 return resultobj;
9725 fail:
9726 return NULL;
9727 }
9728
9729
9730 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9731 PyObject *resultobj;
9732 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9733 bool arg2 ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 char *kwnames[] = {
9737 (char *) "self",(char *) "bDoPass", NULL
9738 };
9739
9740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9742 if (SWIG_arg_fail(1)) SWIG_fail;
9743 {
9744 arg2 = (bool)(SWIG_As_bool(obj1));
9745 if (SWIG_arg_fail(2)) SWIG_fail;
9746 }
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 (arg1)->PassMessages(arg2);
9750
9751 wxPyEndAllowThreads(__tstate);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 Py_INCREF(Py_None); resultobj = Py_None;
9755 return resultobj;
9756 fail:
9757 return NULL;
9758 }
9759
9760
9761 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9762 PyObject *obj;
9763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9764 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9765 Py_INCREF(obj);
9766 return Py_BuildValue((char *)"");
9767 }
9768 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9769 PyObject *resultobj;
9770 wxLog *arg1 = (wxLog *) 0 ;
9771 wxLogChain *result;
9772 PyObject * obj0 = 0 ;
9773 char *kwnames[] = {
9774 (char *) "logger", NULL
9775 };
9776
9777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9779 if (SWIG_arg_fail(1)) SWIG_fail;
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 result = (wxLogChain *)new wxLogChain(arg1);
9783
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9795 PyObject *resultobj;
9796 wxLogChain *arg1 = (wxLogChain *) 0 ;
9797 wxLog *arg2 = (wxLog *) 0 ;
9798 PyObject * obj0 = 0 ;
9799 PyObject * obj1 = 0 ;
9800 char *kwnames[] = {
9801 (char *) "self",(char *) "logger", NULL
9802 };
9803
9804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9806 if (SWIG_arg_fail(1)) SWIG_fail;
9807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(2)) SWIG_fail;
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 (arg1)->SetLog(arg2);
9812
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 Py_INCREF(Py_None); resultobj = Py_None;
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj;
9825 wxLogChain *arg1 = (wxLogChain *) 0 ;
9826 bool arg2 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self",(char *) "bDoPass", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 arg2 = (bool)(SWIG_As_bool(obj1));
9838 if (SWIG_arg_fail(2)) SWIG_fail;
9839 }
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 (arg1)->PassMessages(arg2);
9843
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 Py_INCREF(Py_None); resultobj = Py_None;
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxLogChain *arg1 = (wxLogChain *) 0 ;
9857 bool result;
9858 PyObject * obj0 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 result = (bool)(arg1)->IsPassingMessages();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9875 }
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9883 PyObject *resultobj;
9884 wxLogChain *arg1 = (wxLogChain *) 0 ;
9885 wxLog *result;
9886 PyObject * obj0 = 0 ;
9887 char *kwnames[] = {
9888 (char *) "self", NULL
9889 };
9890
9891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9893 if (SWIG_arg_fail(1)) SWIG_fail;
9894 {
9895 PyThreadState* __tstate = wxPyBeginAllowThreads();
9896 result = (wxLog *)(arg1)->GetOldLog();
9897
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9902 return resultobj;
9903 fail:
9904 return NULL;
9905 }
9906
9907
9908 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9909 PyObject *obj;
9910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9911 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9912 Py_INCREF(obj);
9913 return Py_BuildValue((char *)"");
9914 }
9915 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj;
9917 unsigned long result;
9918 char *kwnames[] = {
9919 NULL
9920 };
9921
9922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9923 {
9924 PyThreadState* __tstate = wxPyBeginAllowThreads();
9925 result = (unsigned long)wxSysErrorCode();
9926
9927 wxPyEndAllowThreads(__tstate);
9928 if (PyErr_Occurred()) SWIG_fail;
9929 }
9930 {
9931 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9932 }
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9940 PyObject *resultobj;
9941 unsigned long arg1 = (unsigned long) 0 ;
9942 wxString result;
9943 PyObject * obj0 = 0 ;
9944 char *kwnames[] = {
9945 (char *) "nErrCode", NULL
9946 };
9947
9948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9949 if (obj0) {
9950 {
9951 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9952 if (SWIG_arg_fail(1)) SWIG_fail;
9953 }
9954 }
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = wxSysErrorMsg(arg1);
9958
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 #if wxUSE_UNICODE
9964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9965 #else
9966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9967 #endif
9968 }
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj;
9977 wxString *arg1 = 0 ;
9978 bool temp1 = false ;
9979 PyObject * obj0 = 0 ;
9980 char *kwnames[] = {
9981 (char *) "msg", NULL
9982 };
9983
9984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9985 {
9986 arg1 = wxString_in_helper(obj0);
9987 if (arg1 == NULL) SWIG_fail;
9988 temp1 = true;
9989 }
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 wxPyLogFatalError((wxString const &)*arg1);
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 Py_INCREF(Py_None); resultobj = Py_None;
9998 {
9999 if (temp1)
10000 delete arg1;
10001 }
10002 return resultobj;
10003 fail:
10004 {
10005 if (temp1)
10006 delete arg1;
10007 }
10008 return NULL;
10009 }
10010
10011
10012 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10013 PyObject *resultobj;
10014 wxString *arg1 = 0 ;
10015 bool temp1 = false ;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "msg", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10022 {
10023 arg1 = wxString_in_helper(obj0);
10024 if (arg1 == NULL) SWIG_fail;
10025 temp1 = true;
10026 }
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 wxPyLogError((wxString const &)*arg1);
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 Py_INCREF(Py_None); resultobj = Py_None;
10035 {
10036 if (temp1)
10037 delete arg1;
10038 }
10039 return resultobj;
10040 fail:
10041 {
10042 if (temp1)
10043 delete arg1;
10044 }
10045 return NULL;
10046 }
10047
10048
10049 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj;
10051 wxString *arg1 = 0 ;
10052 bool temp1 = false ;
10053 PyObject * obj0 = 0 ;
10054 char *kwnames[] = {
10055 (char *) "msg", NULL
10056 };
10057
10058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10059 {
10060 arg1 = wxString_in_helper(obj0);
10061 if (arg1 == NULL) SWIG_fail;
10062 temp1 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 wxPyLogWarning((wxString const &)*arg1);
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 Py_INCREF(Py_None); resultobj = Py_None;
10072 {
10073 if (temp1)
10074 delete arg1;
10075 }
10076 return resultobj;
10077 fail:
10078 {
10079 if (temp1)
10080 delete arg1;
10081 }
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxString *arg1 = 0 ;
10089 bool temp1 = false ;
10090 PyObject * obj0 = 0 ;
10091 char *kwnames[] = {
10092 (char *) "msg", NULL
10093 };
10094
10095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10096 {
10097 arg1 = wxString_in_helper(obj0);
10098 if (arg1 == NULL) SWIG_fail;
10099 temp1 = true;
10100 }
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 wxPyLogMessage((wxString const &)*arg1);
10104
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 Py_INCREF(Py_None); resultobj = Py_None;
10109 {
10110 if (temp1)
10111 delete arg1;
10112 }
10113 return resultobj;
10114 fail:
10115 {
10116 if (temp1)
10117 delete arg1;
10118 }
10119 return NULL;
10120 }
10121
10122
10123 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10124 PyObject *resultobj;
10125 wxString *arg1 = 0 ;
10126 bool temp1 = false ;
10127 PyObject * obj0 = 0 ;
10128 char *kwnames[] = {
10129 (char *) "msg", NULL
10130 };
10131
10132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10133 {
10134 arg1 = wxString_in_helper(obj0);
10135 if (arg1 == NULL) SWIG_fail;
10136 temp1 = true;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 wxPyLogInfo((wxString const &)*arg1);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 {
10147 if (temp1)
10148 delete arg1;
10149 }
10150 return resultobj;
10151 fail:
10152 {
10153 if (temp1)
10154 delete arg1;
10155 }
10156 return NULL;
10157 }
10158
10159
10160 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj;
10162 wxString *arg1 = 0 ;
10163 bool temp1 = false ;
10164 PyObject * obj0 = 0 ;
10165 char *kwnames[] = {
10166 (char *) "msg", NULL
10167 };
10168
10169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10170 {
10171 arg1 = wxString_in_helper(obj0);
10172 if (arg1 == NULL) SWIG_fail;
10173 temp1 = true;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 wxPyLogDebug((wxString const &)*arg1);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 {
10184 if (temp1)
10185 delete arg1;
10186 }
10187 return resultobj;
10188 fail:
10189 {
10190 if (temp1)
10191 delete arg1;
10192 }
10193 return NULL;
10194 }
10195
10196
10197 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj;
10199 wxString *arg1 = 0 ;
10200 bool temp1 = false ;
10201 PyObject * obj0 = 0 ;
10202 char *kwnames[] = {
10203 (char *) "msg", NULL
10204 };
10205
10206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10207 {
10208 arg1 = wxString_in_helper(obj0);
10209 if (arg1 == NULL) SWIG_fail;
10210 temp1 = true;
10211 }
10212 {
10213 PyThreadState* __tstate = wxPyBeginAllowThreads();
10214 wxPyLogVerbose((wxString const &)*arg1);
10215
10216 wxPyEndAllowThreads(__tstate);
10217 if (PyErr_Occurred()) SWIG_fail;
10218 }
10219 Py_INCREF(Py_None); resultobj = Py_None;
10220 {
10221 if (temp1)
10222 delete arg1;
10223 }
10224 return resultobj;
10225 fail:
10226 {
10227 if (temp1)
10228 delete arg1;
10229 }
10230 return NULL;
10231 }
10232
10233
10234 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj;
10236 wxString *arg1 = 0 ;
10237 bool temp1 = false ;
10238 PyObject * obj0 = 0 ;
10239 char *kwnames[] = {
10240 (char *) "msg", NULL
10241 };
10242
10243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10244 {
10245 arg1 = wxString_in_helper(obj0);
10246 if (arg1 == NULL) SWIG_fail;
10247 temp1 = true;
10248 }
10249 {
10250 PyThreadState* __tstate = wxPyBeginAllowThreads();
10251 wxPyLogStatus((wxString const &)*arg1);
10252
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 Py_INCREF(Py_None); resultobj = Py_None;
10257 {
10258 if (temp1)
10259 delete arg1;
10260 }
10261 return resultobj;
10262 fail:
10263 {
10264 if (temp1)
10265 delete arg1;
10266 }
10267 return NULL;
10268 }
10269
10270
10271 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10272 PyObject *resultobj;
10273 wxFrame *arg1 = (wxFrame *) 0 ;
10274 wxString *arg2 = 0 ;
10275 bool temp2 = false ;
10276 PyObject * obj0 = 0 ;
10277 PyObject * obj1 = 0 ;
10278 char *kwnames[] = {
10279 (char *) "pFrame",(char *) "msg", NULL
10280 };
10281
10282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10284 if (SWIG_arg_fail(1)) SWIG_fail;
10285 {
10286 arg2 = wxString_in_helper(obj1);
10287 if (arg2 == NULL) SWIG_fail;
10288 temp2 = true;
10289 }
10290 {
10291 PyThreadState* __tstate = wxPyBeginAllowThreads();
10292 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10293
10294 wxPyEndAllowThreads(__tstate);
10295 if (PyErr_Occurred()) SWIG_fail;
10296 }
10297 Py_INCREF(Py_None); resultobj = Py_None;
10298 {
10299 if (temp2)
10300 delete arg2;
10301 }
10302 return resultobj;
10303 fail:
10304 {
10305 if (temp2)
10306 delete arg2;
10307 }
10308 return NULL;
10309 }
10310
10311
10312 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10313 PyObject *resultobj;
10314 wxString *arg1 = 0 ;
10315 bool temp1 = false ;
10316 PyObject * obj0 = 0 ;
10317 char *kwnames[] = {
10318 (char *) "msg", NULL
10319 };
10320
10321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10322 {
10323 arg1 = wxString_in_helper(obj0);
10324 if (arg1 == NULL) SWIG_fail;
10325 temp1 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 wxPyLogSysError((wxString const &)*arg1);
10330
10331 wxPyEndAllowThreads(__tstate);
10332 if (PyErr_Occurred()) SWIG_fail;
10333 }
10334 Py_INCREF(Py_None); resultobj = Py_None;
10335 {
10336 if (temp1)
10337 delete arg1;
10338 }
10339 return resultobj;
10340 fail:
10341 {
10342 if (temp1)
10343 delete arg1;
10344 }
10345 return NULL;
10346 }
10347
10348
10349 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10350 PyObject *resultobj;
10351 unsigned long arg1 ;
10352 wxString *arg2 = 0 ;
10353 bool temp2 = false ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 char *kwnames[] = {
10357 (char *) "level",(char *) "msg", NULL
10358 };
10359
10360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10361 {
10362 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 }
10365 {
10366 arg2 = wxString_in_helper(obj1);
10367 if (arg2 == NULL) SWIG_fail;
10368 temp2 = true;
10369 }
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10373
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 Py_INCREF(Py_None); resultobj = Py_None;
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return resultobj;
10383 fail:
10384 {
10385 if (temp2)
10386 delete arg2;
10387 }
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10393 PyObject *resultobj;
10394 unsigned long arg1 ;
10395 wxString *arg2 = 0 ;
10396 bool temp2 = false ;
10397 PyObject * obj0 = 0 ;
10398 PyObject * obj1 = 0 ;
10399
10400 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10401 {
10402 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10403 if (SWIG_arg_fail(1)) SWIG_fail;
10404 }
10405 {
10406 arg2 = wxString_in_helper(obj1);
10407 if (arg2 == NULL) SWIG_fail;
10408 temp2 = true;
10409 }
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 wxPyLogTrace(arg1,(wxString const &)*arg2);
10413
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 Py_INCREF(Py_None); resultobj = Py_None;
10418 {
10419 if (temp2)
10420 delete arg2;
10421 }
10422 return resultobj;
10423 fail:
10424 {
10425 if (temp2)
10426 delete arg2;
10427 }
10428 return NULL;
10429 }
10430
10431
10432 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10433 PyObject *resultobj;
10434 wxString *arg1 = 0 ;
10435 wxString *arg2 = 0 ;
10436 bool temp1 = false ;
10437 bool temp2 = false ;
10438 PyObject * obj0 = 0 ;
10439 PyObject * obj1 = 0 ;
10440
10441 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10442 {
10443 arg1 = wxString_in_helper(obj0);
10444 if (arg1 == NULL) SWIG_fail;
10445 temp1 = true;
10446 }
10447 {
10448 arg2 = wxString_in_helper(obj1);
10449 if (arg2 == NULL) SWIG_fail;
10450 temp2 = true;
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 Py_INCREF(Py_None); resultobj = Py_None;
10460 {
10461 if (temp1)
10462 delete arg1;
10463 }
10464 {
10465 if (temp2)
10466 delete arg2;
10467 }
10468 return resultobj;
10469 fail:
10470 {
10471 if (temp1)
10472 delete arg1;
10473 }
10474 {
10475 if (temp2)
10476 delete arg2;
10477 }
10478 return NULL;
10479 }
10480
10481
10482 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10483 int argc;
10484 PyObject *argv[3];
10485 int ii;
10486
10487 argc = PyObject_Length(args);
10488 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10489 argv[ii] = PyTuple_GetItem(args,ii);
10490 }
10491 if (argc == 2) {
10492 int _v;
10493 {
10494 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10495 }
10496 if (_v) {
10497 {
10498 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10499 }
10500 if (_v) {
10501 return _wrap_LogTrace__SWIG_1(self,args);
10502 }
10503 }
10504 }
10505 if (argc == 2) {
10506 int _v;
10507 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10508 if (_v) {
10509 {
10510 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10511 }
10512 if (_v) {
10513 return _wrap_LogTrace__SWIG_0(self,args);
10514 }
10515 }
10516 }
10517
10518 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10519 return NULL;
10520 }
10521
10522
10523 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10524 PyObject *resultobj;
10525 wxString *arg1 = 0 ;
10526 wxString *arg2 = 0 ;
10527 bool temp1 = false ;
10528 bool temp2 = false ;
10529 PyObject * obj0 = 0 ;
10530 PyObject * obj1 = 0 ;
10531 char *kwnames[] = {
10532 (char *) "title",(char *) "text", NULL
10533 };
10534
10535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10536 {
10537 arg1 = wxString_in_helper(obj0);
10538 if (arg1 == NULL) SWIG_fail;
10539 temp1 = true;
10540 }
10541 {
10542 arg2 = wxString_in_helper(obj1);
10543 if (arg2 == NULL) SWIG_fail;
10544 temp2 = true;
10545 }
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10549
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 Py_INCREF(Py_None); resultobj = Py_None;
10554 {
10555 if (temp1)
10556 delete arg1;
10557 }
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return resultobj;
10563 fail:
10564 {
10565 if (temp1)
10566 delete arg1;
10567 }
10568 {
10569 if (temp2)
10570 delete arg2;
10571 }
10572 return NULL;
10573 }
10574
10575
10576 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10577 PyObject *resultobj;
10578 wxLogNull *result;
10579 char *kwnames[] = {
10580 NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxLogNull *)new wxLogNull();
10587
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 wxLogNull *arg1 = (wxLogNull *) 0 ;
10601 PyObject * obj0 = 0 ;
10602 char *kwnames[] = {
10603 (char *) "self", NULL
10604 };
10605
10606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10608 if (SWIG_arg_fail(1)) SWIG_fail;
10609 {
10610 PyThreadState* __tstate = wxPyBeginAllowThreads();
10611 delete arg1;
10612
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 Py_INCREF(Py_None); resultobj = Py_None;
10617 return resultobj;
10618 fail:
10619 return NULL;
10620 }
10621
10622
10623 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10624 PyObject *obj;
10625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10626 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10627 Py_INCREF(obj);
10628 return Py_BuildValue((char *)"");
10629 }
10630 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10631 PyObject *resultobj;
10632 wxPyLog *result;
10633 char *kwnames[] = {
10634 NULL
10635 };
10636
10637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (wxPyLog *)new wxPyLog();
10641
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10653 PyObject *resultobj;
10654 wxPyLog *arg1 = (wxPyLog *) 0 ;
10655 PyObject *arg2 = (PyObject *) 0 ;
10656 PyObject *arg3 = (PyObject *) 0 ;
10657 PyObject * obj0 = 0 ;
10658 PyObject * obj1 = 0 ;
10659 PyObject * obj2 = 0 ;
10660 char *kwnames[] = {
10661 (char *) "self",(char *) "self",(char *) "_class", NULL
10662 };
10663
10664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10666 if (SWIG_arg_fail(1)) SWIG_fail;
10667 arg2 = obj1;
10668 arg3 = obj2;
10669 {
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 (arg1)->_setCallbackInfo(arg2,arg3);
10672
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 Py_INCREF(Py_None); resultobj = Py_None;
10677 return resultobj;
10678 fail:
10679 return NULL;
10680 }
10681
10682
10683 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10684 PyObject *obj;
10685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10686 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10687 Py_INCREF(obj);
10688 return Py_BuildValue((char *)"");
10689 }
10690 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 int arg1 ;
10693 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10694 int arg3 = (int) wxKILL_NOCHILDREN ;
10695 wxKillError result;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 PyObject * obj2 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10704 {
10705 arg1 = (int)(SWIG_As_int(obj0));
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 }
10708 if (obj1) {
10709 {
10710 arg2 = (wxSignal)(SWIG_As_int(obj1));
10711 if (SWIG_arg_fail(2)) SWIG_fail;
10712 }
10713 }
10714 if (obj2) {
10715 {
10716 arg3 = (int)(SWIG_As_int(obj2));
10717 if (SWIG_arg_fail(3)) SWIG_fail;
10718 }
10719 }
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10723
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 resultobj = SWIG_From_int((result));
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj;
10736 int arg1 ;
10737 bool result;
10738 PyObject * obj0 = 0 ;
10739 char *kwnames[] = {
10740 (char *) "pid", NULL
10741 };
10742
10743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10744 {
10745 arg1 = (int)(SWIG_As_int(obj0));
10746 if (SWIG_arg_fail(1)) SWIG_fail;
10747 }
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = (bool)wxPyProcess::Exists(arg1);
10751
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10757 }
10758 return resultobj;
10759 fail:
10760 return NULL;
10761 }
10762
10763
10764 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj;
10766 wxString *arg1 = 0 ;
10767 int arg2 = (int) wxEXEC_ASYNC ;
10768 wxPyProcess *result;
10769 bool temp1 = false ;
10770 PyObject * obj0 = 0 ;
10771 PyObject * obj1 = 0 ;
10772 char *kwnames[] = {
10773 (char *) "cmd",(char *) "flags", NULL
10774 };
10775
10776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10777 {
10778 arg1 = wxString_in_helper(obj0);
10779 if (arg1 == NULL) SWIG_fail;
10780 temp1 = true;
10781 }
10782 if (obj1) {
10783 {
10784 arg2 = (int)(SWIG_As_int(obj1));
10785 if (SWIG_arg_fail(2)) SWIG_fail;
10786 }
10787 }
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10796 {
10797 if (temp1)
10798 delete arg1;
10799 }
10800 return resultobj;
10801 fail:
10802 {
10803 if (temp1)
10804 delete arg1;
10805 }
10806 return NULL;
10807 }
10808
10809
10810 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj;
10812 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10813 int arg2 = (int) -1 ;
10814 wxPyProcess *result;
10815 PyObject * obj0 = 0 ;
10816 PyObject * obj1 = 0 ;
10817 char *kwnames[] = {
10818 (char *) "parent",(char *) "id", NULL
10819 };
10820
10821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10822 if (obj0) {
10823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 }
10826 if (obj1) {
10827 {
10828 arg2 = (int)(SWIG_As_int(obj1));
10829 if (SWIG_arg_fail(2)) SWIG_fail;
10830 }
10831 }
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10835
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10849 PyObject *arg2 = (PyObject *) 0 ;
10850 PyObject *arg3 = (PyObject *) 0 ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 PyObject * obj2 = 0 ;
10854 char *kwnames[] = {
10855 (char *) "self",(char *) "self",(char *) "_class", NULL
10856 };
10857
10858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10860 if (SWIG_arg_fail(1)) SWIG_fail;
10861 arg2 = obj1;
10862 arg3 = obj2;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 (arg1)->_setCallbackInfo(arg2,arg3);
10866
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 Py_INCREF(Py_None); resultobj = Py_None;
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj;
10879 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10880 int arg2 ;
10881 int arg3 ;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 PyObject * obj2 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self",(char *) "pid",(char *) "status", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 arg3 = (int)(SWIG_As_int(obj2));
10898 if (SWIG_arg_fail(3)) SWIG_fail;
10899 }
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 (arg1)->base_OnTerminate(arg2,arg3);
10903
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 Py_INCREF(Py_None); resultobj = Py_None;
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj;
10916 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10917 PyObject * obj0 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->Redirect();
10928
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 Py_INCREF(Py_None); resultobj = Py_None;
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10942 bool result;
10943 PyObject * obj0 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 result = (bool)(arg1)->IsRedirected();
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 {
10959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10960 }
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10970 PyObject * obj0 = 0 ;
10971 char *kwnames[] = {
10972 (char *) "self", NULL
10973 };
10974
10975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10977 if (SWIG_arg_fail(1)) SWIG_fail;
10978 {
10979 PyThreadState* __tstate = wxPyBeginAllowThreads();
10980 (arg1)->Detach();
10981
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 Py_INCREF(Py_None); resultobj = Py_None;
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10993 PyObject *resultobj;
10994 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10995 wxInputStream *result;
10996 PyObject * obj0 = 0 ;
10997 char *kwnames[] = {
10998 (char *) "self", NULL
10999 };
11000
11001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11003 if (SWIG_arg_fail(1)) SWIG_fail;
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 result = (wxInputStream *)(arg1)->GetInputStream();
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 wxPyInputStream * _ptr = NULL;
11013
11014 if (result) {
11015 _ptr = new wxPyInputStream(result);
11016 }
11017 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11018 }
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj;
11027 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11028 wxInputStream *result;
11029 PyObject * obj0 = 0 ;
11030 char *kwnames[] = {
11031 (char *) "self", NULL
11032 };
11033
11034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11036 if (SWIG_arg_fail(1)) SWIG_fail;
11037 {
11038 PyThreadState* __tstate = wxPyBeginAllowThreads();
11039 result = (wxInputStream *)(arg1)->GetErrorStream();
11040
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 {
11045 wxPyInputStream * _ptr = NULL;
11046
11047 if (result) {
11048 _ptr = new wxPyInputStream(result);
11049 }
11050 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11051 }
11052 return resultobj;
11053 fail:
11054 return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj;
11060 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11061 wxOutputStream *result;
11062 PyObject * obj0 = 0 ;
11063 char *kwnames[] = {
11064 (char *) "self", NULL
11065 };
11066
11067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 result = (wxOutputStream *)(arg1)->GetOutputStream();
11073
11074 wxPyEndAllowThreads(__tstate);
11075 if (PyErr_Occurred()) SWIG_fail;
11076 }
11077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11078 return resultobj;
11079 fail:
11080 return NULL;
11081 }
11082
11083
11084 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj;
11086 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11087 PyObject * obj0 = 0 ;
11088 char *kwnames[] = {
11089 (char *) "self", NULL
11090 };
11091
11092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11094 if (SWIG_arg_fail(1)) SWIG_fail;
11095 {
11096 PyThreadState* __tstate = wxPyBeginAllowThreads();
11097 (arg1)->CloseOutput();
11098
11099 wxPyEndAllowThreads(__tstate);
11100 if (PyErr_Occurred()) SWIG_fail;
11101 }
11102 Py_INCREF(Py_None); resultobj = Py_None;
11103 return resultobj;
11104 fail:
11105 return NULL;
11106 }
11107
11108
11109 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11110 PyObject *resultobj;
11111 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11112 bool result;
11113 PyObject * obj0 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 {
11129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11130 }
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj;
11139 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11140 bool result;
11141 PyObject * obj0 = 0 ;
11142 char *kwnames[] = {
11143 (char *) "self", NULL
11144 };
11145
11146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11148 if (SWIG_arg_fail(1)) SWIG_fail;
11149 {
11150 PyThreadState* __tstate = wxPyBeginAllowThreads();
11151 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11152
11153 wxPyEndAllowThreads(__tstate);
11154 if (PyErr_Occurred()) SWIG_fail;
11155 }
11156 {
11157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11158 }
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj;
11167 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11168 bool result;
11169 PyObject * obj0 = 0 ;
11170 char *kwnames[] = {
11171 (char *) "self", NULL
11172 };
11173
11174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11176 if (SWIG_arg_fail(1)) SWIG_fail;
11177 {
11178 PyThreadState* __tstate = wxPyBeginAllowThreads();
11179 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11180
11181 wxPyEndAllowThreads(__tstate);
11182 if (PyErr_Occurred()) SWIG_fail;
11183 }
11184 {
11185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11194 PyObject *obj;
11195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11196 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11197 Py_INCREF(obj);
11198 return Py_BuildValue((char *)"");
11199 }
11200 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11201 PyObject *resultobj;
11202 int arg1 = (int) 0 ;
11203 int arg2 = (int) 0 ;
11204 int arg3 = (int) 0 ;
11205 wxProcessEvent *result;
11206 PyObject * obj0 = 0 ;
11207 PyObject * obj1 = 0 ;
11208 PyObject * obj2 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11214 if (obj0) {
11215 {
11216 arg1 = (int)(SWIG_As_int(obj0));
11217 if (SWIG_arg_fail(1)) SWIG_fail;
11218 }
11219 }
11220 if (obj1) {
11221 {
11222 arg2 = (int)(SWIG_As_int(obj1));
11223 if (SWIG_arg_fail(2)) SWIG_fail;
11224 }
11225 }
11226 if (obj2) {
11227 {
11228 arg3 = (int)(SWIG_As_int(obj2));
11229 if (SWIG_arg_fail(3)) SWIG_fail;
11230 }
11231 }
11232 {
11233 PyThreadState* __tstate = wxPyBeginAllowThreads();
11234 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11235
11236 wxPyEndAllowThreads(__tstate);
11237 if (PyErr_Occurred()) SWIG_fail;
11238 }
11239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj;
11248 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11249 int result;
11250 PyObject * obj0 = 0 ;
11251 char *kwnames[] = {
11252 (char *) "self", NULL
11253 };
11254
11255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11257 if (SWIG_arg_fail(1)) SWIG_fail;
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 result = (int)(arg1)->GetPid();
11261
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 {
11266 resultobj = SWIG_From_int((int)(result));
11267 }
11268 return resultobj;
11269 fail:
11270 return NULL;
11271 }
11272
11273
11274 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11275 PyObject *resultobj;
11276 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11277 int result;
11278 PyObject * obj0 = 0 ;
11279 char *kwnames[] = {
11280 (char *) "self", NULL
11281 };
11282
11283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11285 if (SWIG_arg_fail(1)) SWIG_fail;
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (int)(arg1)->GetExitCode();
11289
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 {
11294 resultobj = SWIG_From_int((int)(result));
11295 }
11296 return resultobj;
11297 fail:
11298 return NULL;
11299 }
11300
11301
11302 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11303 PyObject *resultobj;
11304 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11305 int arg2 ;
11306 PyObject * obj0 = 0 ;
11307 PyObject * obj1 = 0 ;
11308 char *kwnames[] = {
11309 (char *) "self",(char *) "m_pid", NULL
11310 };
11311
11312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11314 if (SWIG_arg_fail(1)) SWIG_fail;
11315 {
11316 arg2 = (int)(SWIG_As_int(obj1));
11317 if (SWIG_arg_fail(2)) SWIG_fail;
11318 }
11319 if (arg1) (arg1)->m_pid = arg2;
11320
11321 Py_INCREF(Py_None); resultobj = Py_None;
11322 return resultobj;
11323 fail:
11324 return NULL;
11325 }
11326
11327
11328 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11329 PyObject *resultobj;
11330 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11331 int result;
11332 PyObject * obj0 = 0 ;
11333 char *kwnames[] = {
11334 (char *) "self", NULL
11335 };
11336
11337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11339 if (SWIG_arg_fail(1)) SWIG_fail;
11340 result = (int) ((arg1)->m_pid);
11341
11342 {
11343 resultobj = SWIG_From_int((int)(result));
11344 }
11345 return resultobj;
11346 fail:
11347 return NULL;
11348 }
11349
11350
11351 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11352 PyObject *resultobj;
11353 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11354 int arg2 ;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 char *kwnames[] = {
11358 (char *) "self",(char *) "m_exitcode", NULL
11359 };
11360
11361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11363 if (SWIG_arg_fail(1)) SWIG_fail;
11364 {
11365 arg2 = (int)(SWIG_As_int(obj1));
11366 if (SWIG_arg_fail(2)) SWIG_fail;
11367 }
11368 if (arg1) (arg1)->m_exitcode = arg2;
11369
11370 Py_INCREF(Py_None); resultobj = Py_None;
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj;
11379 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11380 int result;
11381 PyObject * obj0 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "self", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11388 if (SWIG_arg_fail(1)) SWIG_fail;
11389 result = (int) ((arg1)->m_exitcode);
11390
11391 {
11392 resultobj = SWIG_From_int((int)(result));
11393 }
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11401 PyObject *obj;
11402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11403 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11404 Py_INCREF(obj);
11405 return Py_BuildValue((char *)"");
11406 }
11407 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxString *arg1 = 0 ;
11410 int arg2 = (int) wxEXEC_ASYNC ;
11411 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11412 long result;
11413 bool temp1 = false ;
11414 PyObject * obj0 = 0 ;
11415 PyObject * obj1 = 0 ;
11416 PyObject * obj2 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "command",(char *) "flags",(char *) "process", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 if (obj1) {
11428 {
11429 arg2 = (int)(SWIG_As_int(obj1));
11430 if (SWIG_arg_fail(2)) SWIG_fail;
11431 }
11432 }
11433 if (obj2) {
11434 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11435 if (SWIG_arg_fail(3)) SWIG_fail;
11436 }
11437 {
11438 if (!wxPyCheckForApp()) SWIG_fail;
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11441
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 {
11446 resultobj = SWIG_From_long((long)(result));
11447 }
11448 {
11449 if (temp1)
11450 delete arg1;
11451 }
11452 return resultobj;
11453 fail:
11454 {
11455 if (temp1)
11456 delete arg1;
11457 }
11458 return NULL;
11459 }
11460
11461
11462 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 long arg1 ;
11465 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11466 wxKillError *arg3 = (wxKillError *) 0 ;
11467 int arg4 = (int) wxKILL_NOCHILDREN ;
11468 int result;
11469 wxKillError temp3 ;
11470 PyObject * obj0 = 0 ;
11471 PyObject * obj1 = 0 ;
11472 PyObject * obj2 = 0 ;
11473 char *kwnames[] = {
11474 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11475 };
11476
11477 {
11478 arg3 = &temp3;
11479 }
11480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11481 {
11482 arg1 = (long)(SWIG_As_long(obj0));
11483 if (SWIG_arg_fail(1)) SWIG_fail;
11484 }
11485 if (obj1) {
11486 {
11487 arg2 = (wxSignal)(SWIG_As_int(obj1));
11488 if (SWIG_arg_fail(2)) SWIG_fail;
11489 }
11490 }
11491 if (obj2) {
11492 {
11493 arg4 = (int)(SWIG_As_int(obj2));
11494 if (SWIG_arg_fail(4)) SWIG_fail;
11495 }
11496 }
11497 {
11498 PyThreadState* __tstate = wxPyBeginAllowThreads();
11499 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11500
11501 wxPyEndAllowThreads(__tstate);
11502 if (PyErr_Occurred()) SWIG_fail;
11503 }
11504 {
11505 resultobj = SWIG_From_int((int)(result));
11506 }
11507 {
11508 PyObject* o;
11509 o = PyInt_FromLong((long) (*arg3));
11510 resultobj = t_output_helper(resultobj, o);
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 int arg1 = (int) wxJOYSTICK1 ;
11521 wxJoystick *result;
11522 PyObject * obj0 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "joystick", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11528 if (obj0) {
11529 {
11530 arg1 = (int)(SWIG_As_int(obj0));
11531 if (SWIG_arg_fail(1)) SWIG_fail;
11532 }
11533 }
11534 {
11535 if (!wxPyCheckForApp()) SWIG_fail;
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (wxJoystick *)new wxJoystick(arg1);
11538
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11543 return resultobj;
11544 fail:
11545 return NULL;
11546 }
11547
11548
11549 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj;
11551 wxJoystick *arg1 = (wxJoystick *) 0 ;
11552 PyObject * obj0 = 0 ;
11553 char *kwnames[] = {
11554 (char *) "self", NULL
11555 };
11556
11557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11559 if (SWIG_arg_fail(1)) SWIG_fail;
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 delete arg1;
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 Py_INCREF(Py_None); resultobj = Py_None;
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxJoystick *arg1 = (wxJoystick *) 0 ;
11577 wxPoint result;
11578 PyObject * obj0 = 0 ;
11579 char *kwnames[] = {
11580 (char *) "self", NULL
11581 };
11582
11583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11585 if (SWIG_arg_fail(1)) SWIG_fail;
11586 {
11587 PyThreadState* __tstate = wxPyBeginAllowThreads();
11588 result = (arg1)->GetPosition();
11589
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 {
11594 wxPoint * resultptr;
11595 resultptr = new wxPoint((wxPoint &)(result));
11596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11597 }
11598 return resultobj;
11599 fail:
11600 return NULL;
11601 }
11602
11603
11604 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11605 PyObject *resultobj;
11606 wxJoystick *arg1 = (wxJoystick *) 0 ;
11607 int result;
11608 PyObject * obj0 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 result = (int)(arg1)->GetZPosition();
11619
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 {
11624 resultobj = SWIG_From_int((int)(result));
11625 }
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj;
11634 wxJoystick *arg1 = (wxJoystick *) 0 ;
11635 int result;
11636 PyObject * obj0 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 PyThreadState* __tstate = wxPyBeginAllowThreads();
11646 result = (int)(arg1)->GetButtonState();
11647
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 resultobj = SWIG_From_int((int)(result));
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj;
11662 wxJoystick *arg1 = (wxJoystick *) 0 ;
11663 int result;
11664 PyObject * obj0 = 0 ;
11665 char *kwnames[] = {
11666 (char *) "self", NULL
11667 };
11668
11669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11671 if (SWIG_arg_fail(1)) SWIG_fail;
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (int)(arg1)->GetPOVPosition();
11675
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 {
11680 resultobj = SWIG_From_int((int)(result));
11681 }
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj;
11690 wxJoystick *arg1 = (wxJoystick *) 0 ;
11691 int result;
11692 PyObject * obj0 = 0 ;
11693 char *kwnames[] = {
11694 (char *) "self", NULL
11695 };
11696
11697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(1)) SWIG_fail;
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (int)(arg1)->GetPOVCTSPosition();
11703
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 resultobj = SWIG_From_int((int)(result));
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11717 PyObject *resultobj;
11718 wxJoystick *arg1 = (wxJoystick *) 0 ;
11719 int result;
11720 PyObject * obj0 = 0 ;
11721 char *kwnames[] = {
11722 (char *) "self", NULL
11723 };
11724
11725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11727 if (SWIG_arg_fail(1)) SWIG_fail;
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 result = (int)(arg1)->GetRudderPosition();
11731
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 {
11736 resultobj = SWIG_From_int((int)(result));
11737 }
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11745 PyObject *resultobj;
11746 wxJoystick *arg1 = (wxJoystick *) 0 ;
11747 int result;
11748 PyObject * obj0 = 0 ;
11749 char *kwnames[] = {
11750 (char *) "self", NULL
11751 };
11752
11753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11755 if (SWIG_arg_fail(1)) SWIG_fail;
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (int)(arg1)->GetUPosition();
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 {
11764 resultobj = SWIG_From_int((int)(result));
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj;
11774 wxJoystick *arg1 = (wxJoystick *) 0 ;
11775 int result;
11776 PyObject * obj0 = 0 ;
11777 char *kwnames[] = {
11778 (char *) "self", NULL
11779 };
11780
11781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11783 if (SWIG_arg_fail(1)) SWIG_fail;
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (int)(arg1)->GetVPosition();
11787
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 {
11792 resultobj = SWIG_From_int((int)(result));
11793 }
11794 return resultobj;
11795 fail:
11796 return NULL;
11797 }
11798
11799
11800 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11801 PyObject *resultobj;
11802 wxJoystick *arg1 = (wxJoystick *) 0 ;
11803 int result;
11804 PyObject * obj0 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "self", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11811 if (SWIG_arg_fail(1)) SWIG_fail;
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = (int)(arg1)->GetMovementThreshold();
11815
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 {
11820 resultobj = SWIG_From_int((int)(result));
11821 }
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11829 PyObject *resultobj;
11830 wxJoystick *arg1 = (wxJoystick *) 0 ;
11831 int arg2 ;
11832 PyObject * obj0 = 0 ;
11833 PyObject * obj1 = 0 ;
11834 char *kwnames[] = {
11835 (char *) "self",(char *) "threshold", NULL
11836 };
11837
11838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11840 if (SWIG_arg_fail(1)) SWIG_fail;
11841 {
11842 arg2 = (int)(SWIG_As_int(obj1));
11843 if (SWIG_arg_fail(2)) SWIG_fail;
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 (arg1)->SetMovementThreshold(arg2);
11848
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 Py_INCREF(Py_None); resultobj = Py_None;
11853 return resultobj;
11854 fail:
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxJoystick *arg1 = (wxJoystick *) 0 ;
11862 bool result;
11863 PyObject * obj0 = 0 ;
11864 char *kwnames[] = {
11865 (char *) "self", NULL
11866 };
11867
11868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11870 if (SWIG_arg_fail(1)) SWIG_fail;
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (bool)(arg1)->IsOk();
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxJoystick *arg1 = (wxJoystick *) 0 ;
11890 int result;
11891 PyObject * obj0 = 0 ;
11892 char *kwnames[] = {
11893 (char *) "self", NULL
11894 };
11895
11896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11898 if (SWIG_arg_fail(1)) SWIG_fail;
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (int)(arg1)->GetNumberJoysticks();
11902
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 {
11907 resultobj = SWIG_From_int((int)(result));
11908 }
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj;
11917 wxJoystick *arg1 = (wxJoystick *) 0 ;
11918 int result;
11919 PyObject * obj0 = 0 ;
11920 char *kwnames[] = {
11921 (char *) "self", NULL
11922 };
11923
11924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11926 if (SWIG_arg_fail(1)) SWIG_fail;
11927 {
11928 PyThreadState* __tstate = wxPyBeginAllowThreads();
11929 result = (int)(arg1)->GetManufacturerId();
11930
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 {
11935 resultobj = SWIG_From_int((int)(result));
11936 }
11937 return resultobj;
11938 fail:
11939 return NULL;
11940 }
11941
11942
11943 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj;
11945 wxJoystick *arg1 = (wxJoystick *) 0 ;
11946 int result;
11947 PyObject * obj0 = 0 ;
11948 char *kwnames[] = {
11949 (char *) "self", NULL
11950 };
11951
11952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11954 if (SWIG_arg_fail(1)) SWIG_fail;
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (int)(arg1)->GetProductId();
11958
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 {
11963 resultobj = SWIG_From_int((int)(result));
11964 }
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj;
11973 wxJoystick *arg1 = (wxJoystick *) 0 ;
11974 wxString result;
11975 PyObject * obj0 = 0 ;
11976 char *kwnames[] = {
11977 (char *) "self", NULL
11978 };
11979
11980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11982 if (SWIG_arg_fail(1)) SWIG_fail;
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (arg1)->GetProductName();
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 #if wxUSE_UNICODE
11992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11993 #else
11994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11995 #endif
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxJoystick *arg1 = (wxJoystick *) 0 ;
12006 int result;
12007 PyObject * obj0 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (int)(arg1)->GetXMin();
12018
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 resultobj = SWIG_From_int((int)(result));
12024 }
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxJoystick *arg1 = (wxJoystick *) 0 ;
12034 int result;
12035 PyObject * obj0 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (int)(arg1)->GetYMin();
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 resultobj = SWIG_From_int((int)(result));
12052 }
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxJoystick *arg1 = (wxJoystick *) 0 ;
12062 int result;
12063 PyObject * obj0 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (int)(arg1)->GetZMin();
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 {
12079 resultobj = SWIG_From_int((int)(result));
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxJoystick *arg1 = (wxJoystick *) 0 ;
12090 int result;
12091 PyObject * obj0 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 result = (int)(arg1)->GetXMax();
12102
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 {
12107 resultobj = SWIG_From_int((int)(result));
12108 }
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12116 PyObject *resultobj;
12117 wxJoystick *arg1 = (wxJoystick *) 0 ;
12118 int result;
12119 PyObject * obj0 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "self", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12126 if (SWIG_arg_fail(1)) SWIG_fail;
12127 {
12128 PyThreadState* __tstate = wxPyBeginAllowThreads();
12129 result = (int)(arg1)->GetYMax();
12130
12131 wxPyEndAllowThreads(__tstate);
12132 if (PyErr_Occurred()) SWIG_fail;
12133 }
12134 {
12135 resultobj = SWIG_From_int((int)(result));
12136 }
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12144 PyObject *resultobj;
12145 wxJoystick *arg1 = (wxJoystick *) 0 ;
12146 int result;
12147 PyObject * obj0 = 0 ;
12148 char *kwnames[] = {
12149 (char *) "self", NULL
12150 };
12151
12152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12154 if (SWIG_arg_fail(1)) SWIG_fail;
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (int)(arg1)->GetZMax();
12158
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 {
12163 resultobj = SWIG_From_int((int)(result));
12164 }
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj;
12173 wxJoystick *arg1 = (wxJoystick *) 0 ;
12174 int result;
12175 PyObject * obj0 = 0 ;
12176 char *kwnames[] = {
12177 (char *) "self", NULL
12178 };
12179
12180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12182 if (SWIG_arg_fail(1)) SWIG_fail;
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 result = (int)(arg1)->GetNumberButtons();
12186
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 {
12191 resultobj = SWIG_From_int((int)(result));
12192 }
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj;
12201 wxJoystick *arg1 = (wxJoystick *) 0 ;
12202 int result;
12203 PyObject * obj0 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "self", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (int)(arg1)->GetNumberAxes();
12214
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 resultobj = SWIG_From_int((int)(result));
12220 }
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj;
12229 wxJoystick *arg1 = (wxJoystick *) 0 ;
12230 int result;
12231 PyObject * obj0 = 0 ;
12232 char *kwnames[] = {
12233 (char *) "self", NULL
12234 };
12235
12236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (int)(arg1)->GetMaxButtons();
12242
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 {
12247 resultobj = SWIG_From_int((int)(result));
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxJoystick *arg1 = (wxJoystick *) 0 ;
12258 int result;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (int)(arg1)->GetMaxAxes();
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 resultobj = SWIG_From_int((int)(result));
12276 }
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxJoystick *arg1 = (wxJoystick *) 0 ;
12286 int result;
12287 PyObject * obj0 = 0 ;
12288 char *kwnames[] = {
12289 (char *) "self", NULL
12290 };
12291
12292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12294 if (SWIG_arg_fail(1)) SWIG_fail;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 result = (int)(arg1)->GetPollingMin();
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 resultobj = SWIG_From_int((int)(result));
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj;
12313 wxJoystick *arg1 = (wxJoystick *) 0 ;
12314 int result;
12315 PyObject * obj0 = 0 ;
12316 char *kwnames[] = {
12317 (char *) "self", NULL
12318 };
12319
12320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12322 if (SWIG_arg_fail(1)) SWIG_fail;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (int)(arg1)->GetPollingMax();
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 {
12331 resultobj = SWIG_From_int((int)(result));
12332 }
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxJoystick *arg1 = (wxJoystick *) 0 ;
12342 int result;
12343 PyObject * obj0 = 0 ;
12344 char *kwnames[] = {
12345 (char *) "self", NULL
12346 };
12347
12348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12350 if (SWIG_arg_fail(1)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (int)(arg1)->GetRudderMin();
12354
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 resultobj = SWIG_From_int((int)(result));
12360 }
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12368 PyObject *resultobj;
12369 wxJoystick *arg1 = (wxJoystick *) 0 ;
12370 int result;
12371 PyObject * obj0 = 0 ;
12372 char *kwnames[] = {
12373 (char *) "self", NULL
12374 };
12375
12376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12378 if (SWIG_arg_fail(1)) SWIG_fail;
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (int)(arg1)->GetRudderMax();
12382
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 {
12387 resultobj = SWIG_From_int((int)(result));
12388 }
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj;
12397 wxJoystick *arg1 = (wxJoystick *) 0 ;
12398 int result;
12399 PyObject * obj0 = 0 ;
12400 char *kwnames[] = {
12401 (char *) "self", NULL
12402 };
12403
12404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12406 if (SWIG_arg_fail(1)) SWIG_fail;
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (int)(arg1)->GetUMin();
12410
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 resultobj = SWIG_From_int((int)(result));
12416 }
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj;
12425 wxJoystick *arg1 = (wxJoystick *) 0 ;
12426 int result;
12427 PyObject * obj0 = 0 ;
12428 char *kwnames[] = {
12429 (char *) "self", NULL
12430 };
12431
12432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12434 if (SWIG_arg_fail(1)) SWIG_fail;
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 result = (int)(arg1)->GetUMax();
12438
12439 wxPyEndAllowThreads(__tstate);
12440 if (PyErr_Occurred()) SWIG_fail;
12441 }
12442 {
12443 resultobj = SWIG_From_int((int)(result));
12444 }
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj;
12453 wxJoystick *arg1 = (wxJoystick *) 0 ;
12454 int result;
12455 PyObject * obj0 = 0 ;
12456 char *kwnames[] = {
12457 (char *) "self", NULL
12458 };
12459
12460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12462 if (SWIG_arg_fail(1)) SWIG_fail;
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (int)(arg1)->GetVMin();
12466
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 {
12471 resultobj = SWIG_From_int((int)(result));
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj;
12481 wxJoystick *arg1 = (wxJoystick *) 0 ;
12482 int result;
12483 PyObject * obj0 = 0 ;
12484 char *kwnames[] = {
12485 (char *) "self", NULL
12486 };
12487
12488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12490 if (SWIG_arg_fail(1)) SWIG_fail;
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 result = (int)(arg1)->GetVMax();
12494
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 {
12499 resultobj = SWIG_From_int((int)(result));
12500 }
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj;
12509 wxJoystick *arg1 = (wxJoystick *) 0 ;
12510 bool result;
12511 PyObject * obj0 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = (bool)(arg1)->HasRudder();
12522
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 {
12527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12528 }
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj;
12537 wxJoystick *arg1 = (wxJoystick *) 0 ;
12538 bool result;
12539 PyObject * obj0 = 0 ;
12540 char *kwnames[] = {
12541 (char *) "self", NULL
12542 };
12543
12544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12546 if (SWIG_arg_fail(1)) SWIG_fail;
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (bool)(arg1)->HasZ();
12550
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 {
12555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12556 }
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj;
12565 wxJoystick *arg1 = (wxJoystick *) 0 ;
12566 bool result;
12567 PyObject * obj0 = 0 ;
12568 char *kwnames[] = {
12569 (char *) "self", NULL
12570 };
12571
12572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12574 if (SWIG_arg_fail(1)) SWIG_fail;
12575 {
12576 PyThreadState* __tstate = wxPyBeginAllowThreads();
12577 result = (bool)(arg1)->HasU();
12578
12579 wxPyEndAllowThreads(__tstate);
12580 if (PyErr_Occurred()) SWIG_fail;
12581 }
12582 {
12583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12584 }
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj;
12593 wxJoystick *arg1 = (wxJoystick *) 0 ;
12594 bool result;
12595 PyObject * obj0 = 0 ;
12596 char *kwnames[] = {
12597 (char *) "self", NULL
12598 };
12599
12600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12602 if (SWIG_arg_fail(1)) SWIG_fail;
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 result = (bool)(arg1)->HasV();
12606
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 {
12611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12612 }
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj;
12621 wxJoystick *arg1 = (wxJoystick *) 0 ;
12622 bool result;
12623 PyObject * obj0 = 0 ;
12624 char *kwnames[] = {
12625 (char *) "self", NULL
12626 };
12627
12628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12630 if (SWIG_arg_fail(1)) SWIG_fail;
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (bool)(arg1)->HasPOV();
12634
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12640 }
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj;
12649 wxJoystick *arg1 = (wxJoystick *) 0 ;
12650 bool result;
12651 PyObject * obj0 = 0 ;
12652 char *kwnames[] = {
12653 (char *) "self", NULL
12654 };
12655
12656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12658 if (SWIG_arg_fail(1)) SWIG_fail;
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (bool)(arg1)->HasPOV4Dir();
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 {
12667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12668 }
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj;
12677 wxJoystick *arg1 = (wxJoystick *) 0 ;
12678 bool result;
12679 PyObject * obj0 = 0 ;
12680 char *kwnames[] = {
12681 (char *) "self", NULL
12682 };
12683
12684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12686 if (SWIG_arg_fail(1)) SWIG_fail;
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 result = (bool)(arg1)->HasPOVCTS();
12690
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 {
12695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12696 }
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj;
12705 wxJoystick *arg1 = (wxJoystick *) 0 ;
12706 wxWindow *arg2 = (wxWindow *) 0 ;
12707 int arg3 = (int) 0 ;
12708 bool result;
12709 PyObject * obj0 = 0 ;
12710 PyObject * obj1 = 0 ;
12711 PyObject * obj2 = 0 ;
12712 char *kwnames[] = {
12713 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12714 };
12715
12716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12718 if (SWIG_arg_fail(1)) SWIG_fail;
12719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12720 if (SWIG_arg_fail(2)) SWIG_fail;
12721 if (obj2) {
12722 {
12723 arg3 = (int)(SWIG_As_int(obj2));
12724 if (SWIG_arg_fail(3)) SWIG_fail;
12725 }
12726 }
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 result = (bool)(arg1)->SetCapture(arg2,arg3);
12730
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 {
12735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12736 }
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj;
12745 wxJoystick *arg1 = (wxJoystick *) 0 ;
12746 bool result;
12747 PyObject * obj0 = 0 ;
12748 char *kwnames[] = {
12749 (char *) "self", NULL
12750 };
12751
12752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12754 if (SWIG_arg_fail(1)) SWIG_fail;
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 result = (bool)(arg1)->ReleaseCapture();
12758
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 {
12763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12772 PyObject *obj;
12773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12774 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12775 Py_INCREF(obj);
12776 return Py_BuildValue((char *)"");
12777 }
12778 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12779 PyObject *resultobj;
12780 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12781 int arg2 = (int) 0 ;
12782 int arg3 = (int) wxJOYSTICK1 ;
12783 int arg4 = (int) 0 ;
12784 wxJoystickEvent *result;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 PyObject * obj2 = 0 ;
12788 PyObject * obj3 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12794 if (obj0) {
12795 {
12796 arg1 = (wxEventType)(SWIG_As_int(obj0));
12797 if (SWIG_arg_fail(1)) SWIG_fail;
12798 }
12799 }
12800 if (obj1) {
12801 {
12802 arg2 = (int)(SWIG_As_int(obj1));
12803 if (SWIG_arg_fail(2)) SWIG_fail;
12804 }
12805 }
12806 if (obj2) {
12807 {
12808 arg3 = (int)(SWIG_As_int(obj2));
12809 if (SWIG_arg_fail(3)) SWIG_fail;
12810 }
12811 }
12812 if (obj3) {
12813 {
12814 arg4 = (int)(SWIG_As_int(obj3));
12815 if (SWIG_arg_fail(4)) SWIG_fail;
12816 }
12817 }
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12821
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12833 PyObject *resultobj;
12834 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12835 wxPoint result;
12836 PyObject * obj0 = 0 ;
12837 char *kwnames[] = {
12838 (char *) "self", NULL
12839 };
12840
12841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12843 if (SWIG_arg_fail(1)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12847
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 {
12852 wxPoint * resultptr;
12853 resultptr = new wxPoint((wxPoint &)(result));
12854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12855 }
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12863 PyObject *resultobj;
12864 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12865 int result;
12866 PyObject * obj0 = 0 ;
12867 char *kwnames[] = {
12868 (char *) "self", NULL
12869 };
12870
12871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12873 if (SWIG_arg_fail(1)) SWIG_fail;
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12877
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 {
12882 resultobj = SWIG_From_int((int)(result));
12883 }
12884 return resultobj;
12885 fail:
12886 return NULL;
12887 }
12888
12889
12890 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12891 PyObject *resultobj;
12892 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12893 int result;
12894 PyObject * obj0 = 0 ;
12895 char *kwnames[] = {
12896 (char *) "self", NULL
12897 };
12898
12899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12901 if (SWIG_arg_fail(1)) SWIG_fail;
12902 {
12903 PyThreadState* __tstate = wxPyBeginAllowThreads();
12904 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12905
12906 wxPyEndAllowThreads(__tstate);
12907 if (PyErr_Occurred()) SWIG_fail;
12908 }
12909 {
12910 resultobj = SWIG_From_int((int)(result));
12911 }
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12921 int result;
12922 PyObject * obj0 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "self", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12929 if (SWIG_arg_fail(1)) SWIG_fail;
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12933
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 {
12938 resultobj = SWIG_From_int((int)(result));
12939 }
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj;
12948 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12949 int result;
12950 PyObject * obj0 = 0 ;
12951 char *kwnames[] = {
12952 (char *) "self", NULL
12953 };
12954
12955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12957 if (SWIG_arg_fail(1)) SWIG_fail;
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12961
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 {
12966 resultobj = SWIG_From_int((int)(result));
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12977 int arg2 ;
12978 PyObject * obj0 = 0 ;
12979 PyObject * obj1 = 0 ;
12980 char *kwnames[] = {
12981 (char *) "self",(char *) "stick", NULL
12982 };
12983
12984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12986 if (SWIG_arg_fail(1)) SWIG_fail;
12987 {
12988 arg2 = (int)(SWIG_As_int(obj1));
12989 if (SWIG_arg_fail(2)) SWIG_fail;
12990 }
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 (arg1)->SetJoystick(arg2);
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 Py_INCREF(Py_None); resultobj = Py_None;
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13008 int arg2 ;
13009 PyObject * obj0 = 0 ;
13010 PyObject * obj1 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self",(char *) "state", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 arg2 = (int)(SWIG_As_int(obj1));
13020 if (SWIG_arg_fail(2)) SWIG_fail;
13021 }
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 (arg1)->SetButtonState(arg2);
13025
13026 wxPyEndAllowThreads(__tstate);
13027 if (PyErr_Occurred()) SWIG_fail;
13028 }
13029 Py_INCREF(Py_None); resultobj = Py_None;
13030 return resultobj;
13031 fail:
13032 return NULL;
13033 }
13034
13035
13036 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13037 PyObject *resultobj;
13038 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13039 int arg2 ;
13040 PyObject * obj0 = 0 ;
13041 PyObject * obj1 = 0 ;
13042 char *kwnames[] = {
13043 (char *) "self",(char *) "change", NULL
13044 };
13045
13046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13048 if (SWIG_arg_fail(1)) SWIG_fail;
13049 {
13050 arg2 = (int)(SWIG_As_int(obj1));
13051 if (SWIG_arg_fail(2)) SWIG_fail;
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 (arg1)->SetButtonChange(arg2);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 Py_INCREF(Py_None); resultobj = Py_None;
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13070 wxPoint *arg2 = 0 ;
13071 wxPoint temp2 ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "pos", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 arg2 = &temp2;
13083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13084 }
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 (arg1)->SetPosition((wxPoint const &)*arg2);
13088
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 Py_INCREF(Py_None); resultobj = Py_None;
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13100 PyObject *resultobj;
13101 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13102 int arg2 ;
13103 PyObject * obj0 = 0 ;
13104 PyObject * obj1 = 0 ;
13105 char *kwnames[] = {
13106 (char *) "self",(char *) "zPos", NULL
13107 };
13108
13109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13111 if (SWIG_arg_fail(1)) SWIG_fail;
13112 {
13113 arg2 = (int)(SWIG_As_int(obj1));
13114 if (SWIG_arg_fail(2)) SWIG_fail;
13115 }
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 (arg1)->SetZPosition(arg2);
13119
13120 wxPyEndAllowThreads(__tstate);
13121 if (PyErr_Occurred()) SWIG_fail;
13122 }
13123 Py_INCREF(Py_None); resultobj = Py_None;
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13131 PyObject *resultobj;
13132 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13133 bool result;
13134 PyObject * obj0 = 0 ;
13135 char *kwnames[] = {
13136 (char *) "self", NULL
13137 };
13138
13139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13141 if (SWIG_arg_fail(1)) SWIG_fail;
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 {
13150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13151 }
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj;
13160 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13161 bool result;
13162 PyObject * obj0 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "self", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13179 }
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13189 bool result;
13190 PyObject * obj0 = 0 ;
13191 char *kwnames[] = {
13192 (char *) "self", NULL
13193 };
13194
13195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13197 if (SWIG_arg_fail(1)) SWIG_fail;
13198 {
13199 PyThreadState* __tstate = wxPyBeginAllowThreads();
13200 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13201
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13207 }
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj;
13216 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13217 int arg2 = (int) wxJOY_BUTTON_ANY ;
13218 bool result;
13219 PyObject * obj0 = 0 ;
13220 PyObject * obj1 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self",(char *) "but", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(1)) SWIG_fail;
13228 if (obj1) {
13229 {
13230 arg2 = (int)(SWIG_As_int(obj1));
13231 if (SWIG_arg_fail(2)) SWIG_fail;
13232 }
13233 }
13234 {
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13237
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 {
13242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13243 }
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13253 int arg2 = (int) wxJOY_BUTTON_ANY ;
13254 bool result;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 char *kwnames[] = {
13258 (char *) "self",(char *) "but", NULL
13259 };
13260
13261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13263 if (SWIG_arg_fail(1)) SWIG_fail;
13264 if (obj1) {
13265 {
13266 arg2 = (int)(SWIG_As_int(obj1));
13267 if (SWIG_arg_fail(2)) SWIG_fail;
13268 }
13269 }
13270 {
13271 PyThreadState* __tstate = wxPyBeginAllowThreads();
13272 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13273
13274 wxPyEndAllowThreads(__tstate);
13275 if (PyErr_Occurred()) SWIG_fail;
13276 }
13277 {
13278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13279 }
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13287 PyObject *resultobj;
13288 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13289 int arg2 = (int) wxJOY_BUTTON_ANY ;
13290 bool result;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "but", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 if (obj1) {
13301 {
13302 arg2 = (int)(SWIG_As_int(obj1));
13303 if (SWIG_arg_fail(2)) SWIG_fail;
13304 }
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 {
13314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13315 }
13316 return resultobj;
13317 fail:
13318 return NULL;
13319 }
13320
13321
13322 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13323 PyObject *obj;
13324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13325 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13326 Py_INCREF(obj);
13327 return Py_BuildValue((char *)"");
13328 }
13329 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj;
13331 wxString const &arg1_defvalue = wxPyEmptyString ;
13332 wxString *arg1 = (wxString *) &arg1_defvalue ;
13333 wxSound *result;
13334 bool temp1 = false ;
13335 PyObject * obj0 = 0 ;
13336 char *kwnames[] = {
13337 (char *) "fileName", NULL
13338 };
13339
13340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13341 if (obj0) {
13342 {
13343 arg1 = wxString_in_helper(obj0);
13344 if (arg1 == NULL) SWIG_fail;
13345 temp1 = true;
13346 }
13347 }
13348 {
13349 if (!wxPyCheckForApp()) SWIG_fail;
13350 PyThreadState* __tstate = wxPyBeginAllowThreads();
13351 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13352
13353 wxPyEndAllowThreads(__tstate);
13354 if (PyErr_Occurred()) SWIG_fail;
13355 }
13356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13357 {
13358 if (temp1)
13359 delete arg1;
13360 }
13361 return resultobj;
13362 fail:
13363 {
13364 if (temp1)
13365 delete arg1;
13366 }
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 PyObject *arg1 = (PyObject *) 0 ;
13374 wxSound *result;
13375 PyObject * obj0 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "data", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13381 arg1 = obj0;
13382 {
13383 if (!wxPyCheckForApp()) SWIG_fail;
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 result = (wxSound *)new_wxSound(arg1);
13386
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj;
13399 wxSound *arg1 = (wxSound *) 0 ;
13400 PyObject * obj0 = 0 ;
13401 char *kwnames[] = {
13402 (char *) "self", NULL
13403 };
13404
13405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13407 if (SWIG_arg_fail(1)) SWIG_fail;
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 delete arg1;
13411
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 Py_INCREF(Py_None); resultobj = Py_None;
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj;
13424 wxSound *arg1 = (wxSound *) 0 ;
13425 wxString *arg2 = 0 ;
13426 bool result;
13427 bool temp2 = false ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 char *kwnames[] = {
13431 (char *) "self",(char *) "fileName", NULL
13432 };
13433
13434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13436 if (SWIG_arg_fail(1)) SWIG_fail;
13437 {
13438 arg2 = wxString_in_helper(obj1);
13439 if (arg2 == NULL) SWIG_fail;
13440 temp2 = true;
13441 }
13442 {
13443 PyThreadState* __tstate = wxPyBeginAllowThreads();
13444 result = (bool)(arg1)->Create((wxString const &)*arg2);
13445
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 {
13450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13451 }
13452 {
13453 if (temp2)
13454 delete arg2;
13455 }
13456 return resultobj;
13457 fail:
13458 {
13459 if (temp2)
13460 delete arg2;
13461 }
13462 return NULL;
13463 }
13464
13465
13466 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj;
13468 wxSound *arg1 = (wxSound *) 0 ;
13469 PyObject *arg2 = (PyObject *) 0 ;
13470 bool result;
13471 PyObject * obj0 = 0 ;
13472 PyObject * obj1 = 0 ;
13473 char *kwnames[] = {
13474 (char *) "self",(char *) "data", NULL
13475 };
13476
13477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13479 if (SWIG_arg_fail(1)) SWIG_fail;
13480 arg2 = obj1;
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = (bool)wxSound_CreateFromData(arg1,arg2);
13484
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 {
13489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13490 }
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj;
13499 wxSound *arg1 = (wxSound *) 0 ;
13500 bool result;
13501 PyObject * obj0 = 0 ;
13502 char *kwnames[] = {
13503 (char *) "self", NULL
13504 };
13505
13506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13508 if (SWIG_arg_fail(1)) SWIG_fail;
13509 {
13510 PyThreadState* __tstate = wxPyBeginAllowThreads();
13511 result = (bool)(arg1)->IsOk();
13512
13513 wxPyEndAllowThreads(__tstate);
13514 if (PyErr_Occurred()) SWIG_fail;
13515 }
13516 {
13517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13518 }
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj;
13527 wxSound *arg1 = (wxSound *) 0 ;
13528 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13529 bool result;
13530 PyObject * obj0 = 0 ;
13531 PyObject * obj1 = 0 ;
13532 char *kwnames[] = {
13533 (char *) "self",(char *) "flags", NULL
13534 };
13535
13536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13538 if (SWIG_arg_fail(1)) SWIG_fail;
13539 if (obj1) {
13540 {
13541 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13542 if (SWIG_arg_fail(2)) SWIG_fail;
13543 }
13544 }
13545 {
13546 if (!wxPyCheckForApp()) SWIG_fail;
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (bool)((wxSound const *)arg1)->Play(arg2);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13555 }
13556 return resultobj;
13557 fail:
13558 return NULL;
13559 }
13560
13561
13562 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj;
13564 wxString *arg1 = 0 ;
13565 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13566 bool result;
13567 bool temp1 = false ;
13568 PyObject * obj0 = 0 ;
13569 PyObject * obj1 = 0 ;
13570 char *kwnames[] = {
13571 (char *) "filename",(char *) "flags", NULL
13572 };
13573
13574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13575 {
13576 arg1 = wxString_in_helper(obj0);
13577 if (arg1 == NULL) SWIG_fail;
13578 temp1 = true;
13579 }
13580 if (obj1) {
13581 {
13582 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13583 if (SWIG_arg_fail(2)) SWIG_fail;
13584 }
13585 }
13586 {
13587 if (!wxPyCheckForApp()) SWIG_fail;
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 {
13595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13596 }
13597 {
13598 if (temp1)
13599 delete arg1;
13600 }
13601 return resultobj;
13602 fail:
13603 {
13604 if (temp1)
13605 delete arg1;
13606 }
13607 return NULL;
13608 }
13609
13610
13611 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13612 PyObject *resultobj;
13613 char *kwnames[] = {
13614 NULL
13615 };
13616
13617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13618 {
13619 if (!wxPyCheckForApp()) SWIG_fail;
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 wxSound::Stop();
13622
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 Py_INCREF(Py_None); resultobj = Py_None;
13627 return resultobj;
13628 fail:
13629 return NULL;
13630 }
13631
13632
13633 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13634 PyObject *obj;
13635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13636 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13637 Py_INCREF(obj);
13638 return Py_BuildValue((char *)"");
13639 }
13640 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj;
13642 wxString *arg1 = 0 ;
13643 wxString *arg2 = 0 ;
13644 wxString *arg3 = 0 ;
13645 wxString *arg4 = 0 ;
13646 wxFileTypeInfo *result;
13647 bool temp1 = false ;
13648 bool temp2 = false ;
13649 bool temp3 = false ;
13650 bool temp4 = false ;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 PyObject * obj2 = 0 ;
13654 PyObject * obj3 = 0 ;
13655 char *kwnames[] = {
13656 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13660 {
13661 arg1 = wxString_in_helper(obj0);
13662 if (arg1 == NULL) SWIG_fail;
13663 temp1 = true;
13664 }
13665 {
13666 arg2 = wxString_in_helper(obj1);
13667 if (arg2 == NULL) SWIG_fail;
13668 temp2 = true;
13669 }
13670 {
13671 arg3 = wxString_in_helper(obj2);
13672 if (arg3 == NULL) SWIG_fail;
13673 temp3 = true;
13674 }
13675 {
13676 arg4 = wxString_in_helper(obj3);
13677 if (arg4 == NULL) SWIG_fail;
13678 temp4 = true;
13679 }
13680 {
13681 PyThreadState* __tstate = wxPyBeginAllowThreads();
13682 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13683
13684 wxPyEndAllowThreads(__tstate);
13685 if (PyErr_Occurred()) SWIG_fail;
13686 }
13687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13688 {
13689 if (temp1)
13690 delete arg1;
13691 }
13692 {
13693 if (temp2)
13694 delete arg2;
13695 }
13696 {
13697 if (temp3)
13698 delete arg3;
13699 }
13700 {
13701 if (temp4)
13702 delete arg4;
13703 }
13704 return resultobj;
13705 fail:
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 {
13711 if (temp2)
13712 delete arg2;
13713 }
13714 {
13715 if (temp3)
13716 delete arg3;
13717 }
13718 {
13719 if (temp4)
13720 delete arg4;
13721 }
13722 return NULL;
13723 }
13724
13725
13726 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13727 PyObject *resultobj;
13728 wxArrayString *arg1 = 0 ;
13729 wxFileTypeInfo *result;
13730 bool temp1 = false ;
13731 PyObject * obj0 = 0 ;
13732 char *kwnames[] = {
13733 (char *) "sArray", NULL
13734 };
13735
13736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13737 {
13738 if (! PySequence_Check(obj0)) {
13739 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13740 SWIG_fail;
13741 }
13742 arg1 = new wxArrayString;
13743 temp1 = true;
13744 int i, len=PySequence_Length(obj0);
13745 for (i=0; i<len; i++) {
13746 PyObject* item = PySequence_GetItem(obj0, i);
13747 #if wxUSE_UNICODE
13748 PyObject* str = PyObject_Unicode(item);
13749 #else
13750 PyObject* str = PyObject_Str(item);
13751 #endif
13752 if (PyErr_Occurred()) SWIG_fail;
13753 arg1->Add(Py2wxString(str));
13754 Py_DECREF(item);
13755 Py_DECREF(str);
13756 }
13757 }
13758 {
13759 PyThreadState* __tstate = wxPyBeginAllowThreads();
13760 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13761
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13766 {
13767 if (temp1) delete arg1;
13768 }
13769 return resultobj;
13770 fail:
13771 {
13772 if (temp1) delete arg1;
13773 }
13774 return NULL;
13775 }
13776
13777
13778 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj;
13780 wxFileTypeInfo *result;
13781 char *kwnames[] = {
13782 NULL
13783 };
13784
13785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13786 {
13787 PyThreadState* __tstate = wxPyBeginAllowThreads();
13788 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13789
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj;
13802 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13803 bool result;
13804 PyObject * obj0 = 0 ;
13805 char *kwnames[] = {
13806 (char *) "self", NULL
13807 };
13808
13809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13811 if (SWIG_arg_fail(1)) SWIG_fail;
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13815
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 {
13820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13821 }
13822 return resultobj;
13823 fail:
13824 return NULL;
13825 }
13826
13827
13828 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj;
13830 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13831 wxString *arg2 = 0 ;
13832 int arg3 = (int) 0 ;
13833 bool temp2 = false ;
13834 PyObject * obj0 = 0 ;
13835 PyObject * obj1 = 0 ;
13836 PyObject * obj2 = 0 ;
13837 char *kwnames[] = {
13838 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13839 };
13840
13841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13843 if (SWIG_arg_fail(1)) SWIG_fail;
13844 {
13845 arg2 = wxString_in_helper(obj1);
13846 if (arg2 == NULL) SWIG_fail;
13847 temp2 = true;
13848 }
13849 if (obj2) {
13850 {
13851 arg3 = (int)(SWIG_As_int(obj2));
13852 if (SWIG_arg_fail(3)) SWIG_fail;
13853 }
13854 }
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13858
13859 wxPyEndAllowThreads(__tstate);
13860 if (PyErr_Occurred()) SWIG_fail;
13861 }
13862 Py_INCREF(Py_None); resultobj = Py_None;
13863 {
13864 if (temp2)
13865 delete arg2;
13866 }
13867 return resultobj;
13868 fail:
13869 {
13870 if (temp2)
13871 delete arg2;
13872 }
13873 return NULL;
13874 }
13875
13876
13877 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13878 PyObject *resultobj;
13879 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13880 wxString *arg2 = 0 ;
13881 bool temp2 = false ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 char *kwnames[] = {
13885 (char *) "self",(char *) "shortDesc", NULL
13886 };
13887
13888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13890 if (SWIG_arg_fail(1)) SWIG_fail;
13891 {
13892 arg2 = wxString_in_helper(obj1);
13893 if (arg2 == NULL) SWIG_fail;
13894 temp2 = true;
13895 }
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 (arg1)->SetShortDesc((wxString const &)*arg2);
13899
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 Py_INCREF(Py_None); resultobj = Py_None;
13904 {
13905 if (temp2)
13906 delete arg2;
13907 }
13908 return resultobj;
13909 fail:
13910 {
13911 if (temp2)
13912 delete arg2;
13913 }
13914 return NULL;
13915 }
13916
13917
13918 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj;
13920 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13921 wxString *result;
13922 PyObject * obj0 = 0 ;
13923 char *kwnames[] = {
13924 (char *) "self", NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13929 if (SWIG_arg_fail(1)) SWIG_fail;
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 {
13933 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13934 result = (wxString *) &_result_ref;
13935 }
13936
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 {
13941 #if wxUSE_UNICODE
13942 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13943 #else
13944 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13945 #endif
13946 }
13947 return resultobj;
13948 fail:
13949 return NULL;
13950 }
13951
13952
13953 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj;
13955 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13956 wxString *result;
13957 PyObject * obj0 = 0 ;
13958 char *kwnames[] = {
13959 (char *) "self", NULL
13960 };
13961
13962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13964 if (SWIG_arg_fail(1)) SWIG_fail;
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 {
13968 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13969 result = (wxString *) &_result_ref;
13970 }
13971
13972 wxPyEndAllowThreads(__tstate);
13973 if (PyErr_Occurred()) SWIG_fail;
13974 }
13975 {
13976 #if wxUSE_UNICODE
13977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13978 #else
13979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13980 #endif
13981 }
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj;
13990 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13991 wxString *result;
13992 PyObject * obj0 = 0 ;
13993 char *kwnames[] = {
13994 (char *) "self", NULL
13995 };
13996
13997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13999 if (SWIG_arg_fail(1)) SWIG_fail;
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 {
14003 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14004 result = (wxString *) &_result_ref;
14005 }
14006
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 {
14011 #if wxUSE_UNICODE
14012 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14013 #else
14014 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14015 #endif
14016 }
14017 return resultobj;
14018 fail:
14019 return NULL;
14020 }
14021
14022
14023 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14024 PyObject *resultobj;
14025 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14026 wxString *result;
14027 PyObject * obj0 = 0 ;
14028 char *kwnames[] = {
14029 (char *) "self", NULL
14030 };
14031
14032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14034 if (SWIG_arg_fail(1)) SWIG_fail;
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 {
14038 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14039 result = (wxString *) &_result_ref;
14040 }
14041
14042 wxPyEndAllowThreads(__tstate);
14043 if (PyErr_Occurred()) SWIG_fail;
14044 }
14045 {
14046 #if wxUSE_UNICODE
14047 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14048 #else
14049 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14050 #endif
14051 }
14052 return resultobj;
14053 fail:
14054 return NULL;
14055 }
14056
14057
14058 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14059 PyObject *resultobj;
14060 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14061 wxString *result;
14062 PyObject * obj0 = 0 ;
14063 char *kwnames[] = {
14064 (char *) "self", NULL
14065 };
14066
14067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14069 if (SWIG_arg_fail(1)) SWIG_fail;
14070 {
14071 PyThreadState* __tstate = wxPyBeginAllowThreads();
14072 {
14073 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14074 result = (wxString *) &_result_ref;
14075 }
14076
14077 wxPyEndAllowThreads(__tstate);
14078 if (PyErr_Occurred()) SWIG_fail;
14079 }
14080 {
14081 #if wxUSE_UNICODE
14082 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14083 #else
14084 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14085 #endif
14086 }
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj;
14095 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14096 wxArrayString *result;
14097 PyObject * obj0 = 0 ;
14098 char *kwnames[] = {
14099 (char *) "self", NULL
14100 };
14101
14102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14104 if (SWIG_arg_fail(1)) SWIG_fail;
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 {
14108 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14109 result = (wxArrayString *) &_result_ref;
14110 }
14111
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 {
14116 resultobj = wxArrayString2PyList_helper(*result);
14117 }
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14125 PyObject *resultobj;
14126 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14127 int result;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = SWIG_From_int((int)(result));
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14153 PyObject *resultobj;
14154 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14155 wxString *result;
14156 PyObject * obj0 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14163 if (SWIG_arg_fail(1)) SWIG_fail;
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 {
14167 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14168 result = (wxString *) &_result_ref;
14169 }
14170
14171 wxPyEndAllowThreads(__tstate);
14172 if (PyErr_Occurred()) SWIG_fail;
14173 }
14174 {
14175 #if wxUSE_UNICODE
14176 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14177 #else
14178 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14179 #endif
14180 }
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14188 PyObject *resultobj;
14189 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14190 int result;
14191 PyObject * obj0 = 0 ;
14192 char *kwnames[] = {
14193 (char *) "self", NULL
14194 };
14195
14196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14198 if (SWIG_arg_fail(1)) SWIG_fail;
14199 {
14200 PyThreadState* __tstate = wxPyBeginAllowThreads();
14201 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14202
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 {
14207 resultobj = SWIG_From_int((int)(result));
14208 }
14209 return resultobj;
14210 fail:
14211 return NULL;
14212 }
14213
14214
14215 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14216 PyObject *obj;
14217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14218 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14219 Py_INCREF(obj);
14220 return Py_BuildValue((char *)"");
14221 }
14222 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14223 PyObject *resultobj;
14224 wxFileTypeInfo *arg1 = 0 ;
14225 wxFileType *result;
14226 PyObject * obj0 = 0 ;
14227 char *kwnames[] = {
14228 (char *) "ftInfo", NULL
14229 };
14230
14231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14232 {
14233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14234 if (SWIG_arg_fail(1)) SWIG_fail;
14235 if (arg1 == NULL) {
14236 SWIG_null_ref("wxFileTypeInfo");
14237 }
14238 if (SWIG_arg_fail(1)) SWIG_fail;
14239 }
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14243
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxFileType *arg1 = (wxFileType *) 0 ;
14257 PyObject * obj0 = 0 ;
14258 char *kwnames[] = {
14259 (char *) "self", NULL
14260 };
14261
14262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14264 if (SWIG_arg_fail(1)) SWIG_fail;
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 delete arg1;
14268
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 Py_INCREF(Py_None); resultobj = Py_None;
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14280 PyObject *resultobj;
14281 wxFileType *arg1 = (wxFileType *) 0 ;
14282 PyObject *result;
14283 PyObject * obj0 = 0 ;
14284 char *kwnames[] = {
14285 (char *) "self", NULL
14286 };
14287
14288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (PyObject *)wxFileType_GetMimeType(arg1);
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 resultobj = result;
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14306 PyObject *resultobj;
14307 wxFileType *arg1 = (wxFileType *) 0 ;
14308 PyObject *result;
14309 PyObject * obj0 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "self", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14316 if (SWIG_arg_fail(1)) SWIG_fail;
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = result;
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14332 PyObject *resultobj;
14333 wxFileType *arg1 = (wxFileType *) 0 ;
14334 PyObject *result;
14335 PyObject * obj0 = 0 ;
14336 char *kwnames[] = {
14337 (char *) "self", NULL
14338 };
14339
14340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14342 if (SWIG_arg_fail(1)) SWIG_fail;
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (PyObject *)wxFileType_GetExtensions(arg1);
14346
14347 wxPyEndAllowThreads(__tstate);
14348 if (PyErr_Occurred()) SWIG_fail;
14349 }
14350 resultobj = result;
14351 return resultobj;
14352 fail:
14353 return NULL;
14354 }
14355
14356
14357 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14358 PyObject *resultobj;
14359 wxFileType *arg1 = (wxFileType *) 0 ;
14360 wxIcon *result;
14361 PyObject * obj0 = 0 ;
14362 char *kwnames[] = {
14363 (char *) "self", NULL
14364 };
14365
14366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14368 if (SWIG_arg_fail(1)) SWIG_fail;
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (wxIcon *)wxFileType_GetIcon(arg1);
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj;
14385 wxFileType *arg1 = (wxFileType *) 0 ;
14386 PyObject *result;
14387 PyObject * obj0 = 0 ;
14388 char *kwnames[] = {
14389 (char *) "self", NULL
14390 };
14391
14392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14394 if (SWIG_arg_fail(1)) SWIG_fail;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = result;
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj;
14411 wxFileType *arg1 = (wxFileType *) 0 ;
14412 PyObject *result;
14413 PyObject * obj0 = 0 ;
14414 char *kwnames[] = {
14415 (char *) "self", NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(1)) SWIG_fail;
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 result = (PyObject *)wxFileType_GetDescription(arg1);
14424
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 resultobj = result;
14429 return resultobj;
14430 fail:
14431 return NULL;
14432 }
14433
14434
14435 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj;
14437 wxFileType *arg1 = (wxFileType *) 0 ;
14438 wxString *arg2 = 0 ;
14439 wxString const &arg3_defvalue = wxPyEmptyString ;
14440 wxString *arg3 = (wxString *) &arg3_defvalue ;
14441 PyObject *result;
14442 bool temp2 = false ;
14443 bool temp3 = false ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 PyObject * obj2 = 0 ;
14447 char *kwnames[] = {
14448 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14449 };
14450
14451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14453 if (SWIG_arg_fail(1)) SWIG_fail;
14454 {
14455 arg2 = wxString_in_helper(obj1);
14456 if (arg2 == NULL) SWIG_fail;
14457 temp2 = true;
14458 }
14459 if (obj2) {
14460 {
14461 arg3 = wxString_in_helper(obj2);
14462 if (arg3 == NULL) SWIG_fail;
14463 temp3 = true;
14464 }
14465 }
14466 {
14467 PyThreadState* __tstate = wxPyBeginAllowThreads();
14468 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14469
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = result;
14474 {
14475 if (temp2)
14476 delete arg2;
14477 }
14478 {
14479 if (temp3)
14480 delete arg3;
14481 }
14482 return resultobj;
14483 fail:
14484 {
14485 if (temp2)
14486 delete arg2;
14487 }
14488 {
14489 if (temp3)
14490 delete arg3;
14491 }
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj;
14498 wxFileType *arg1 = (wxFileType *) 0 ;
14499 wxString *arg2 = 0 ;
14500 wxString const &arg3_defvalue = wxPyEmptyString ;
14501 wxString *arg3 = (wxString *) &arg3_defvalue ;
14502 PyObject *result;
14503 bool temp2 = false ;
14504 bool temp3 = false ;
14505 PyObject * obj0 = 0 ;
14506 PyObject * obj1 = 0 ;
14507 PyObject * obj2 = 0 ;
14508 char *kwnames[] = {
14509 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14510 };
14511
14512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14514 if (SWIG_arg_fail(1)) SWIG_fail;
14515 {
14516 arg2 = wxString_in_helper(obj1);
14517 if (arg2 == NULL) SWIG_fail;
14518 temp2 = true;
14519 }
14520 if (obj2) {
14521 {
14522 arg3 = wxString_in_helper(obj2);
14523 if (arg3 == NULL) SWIG_fail;
14524 temp3 = true;
14525 }
14526 }
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14530
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 resultobj = result;
14535 {
14536 if (temp2)
14537 delete arg2;
14538 }
14539 {
14540 if (temp3)
14541 delete arg3;
14542 }
14543 return resultobj;
14544 fail:
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 {
14550 if (temp3)
14551 delete arg3;
14552 }
14553 return NULL;
14554 }
14555
14556
14557 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj;
14559 wxFileType *arg1 = (wxFileType *) 0 ;
14560 wxString *arg2 = 0 ;
14561 wxString const &arg3_defvalue = wxPyEmptyString ;
14562 wxString *arg3 = (wxString *) &arg3_defvalue ;
14563 PyObject *result;
14564 bool temp2 = false ;
14565 bool temp3 = false ;
14566 PyObject * obj0 = 0 ;
14567 PyObject * obj1 = 0 ;
14568 PyObject * obj2 = 0 ;
14569 char *kwnames[] = {
14570 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14571 };
14572
14573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14575 if (SWIG_arg_fail(1)) SWIG_fail;
14576 {
14577 arg2 = wxString_in_helper(obj1);
14578 if (arg2 == NULL) SWIG_fail;
14579 temp2 = true;
14580 }
14581 if (obj2) {
14582 {
14583 arg3 = wxString_in_helper(obj2);
14584 if (arg3 == NULL) SWIG_fail;
14585 temp3 = true;
14586 }
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14591
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = result;
14596 {
14597 if (temp2)
14598 delete arg2;
14599 }
14600 {
14601 if (temp3)
14602 delete arg3;
14603 }
14604 return resultobj;
14605 fail:
14606 {
14607 if (temp2)
14608 delete arg2;
14609 }
14610 {
14611 if (temp3)
14612 delete arg3;
14613 }
14614 return NULL;
14615 }
14616
14617
14618 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14619 PyObject *resultobj;
14620 wxFileType *arg1 = (wxFileType *) 0 ;
14621 wxString *arg2 = 0 ;
14622 wxString *arg3 = 0 ;
14623 bool arg4 = (bool) true ;
14624 bool result;
14625 bool temp2 = false ;
14626 bool temp3 = false ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 PyObject * obj2 = 0 ;
14630 PyObject * obj3 = 0 ;
14631 char *kwnames[] = {
14632 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14633 };
14634
14635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14637 if (SWIG_arg_fail(1)) SWIG_fail;
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 {
14644 arg3 = wxString_in_helper(obj2);
14645 if (arg3 == NULL) SWIG_fail;
14646 temp3 = true;
14647 }
14648 if (obj3) {
14649 {
14650 arg4 = (bool)(SWIG_As_bool(obj3));
14651 if (SWIG_arg_fail(4)) SWIG_fail;
14652 }
14653 }
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14663 }
14664 {
14665 if (temp2)
14666 delete arg2;
14667 }
14668 {
14669 if (temp3)
14670 delete arg3;
14671 }
14672 return resultobj;
14673 fail:
14674 {
14675 if (temp2)
14676 delete arg2;
14677 }
14678 {
14679 if (temp3)
14680 delete arg3;
14681 }
14682 return NULL;
14683 }
14684
14685
14686 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14687 PyObject *resultobj;
14688 wxFileType *arg1 = (wxFileType *) 0 ;
14689 wxString const &arg2_defvalue = wxPyEmptyString ;
14690 wxString *arg2 = (wxString *) &arg2_defvalue ;
14691 int arg3 = (int) 0 ;
14692 bool result;
14693 bool temp2 = false ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 PyObject * obj2 = 0 ;
14697 char *kwnames[] = {
14698 (char *) "self",(char *) "cmd",(char *) "index", NULL
14699 };
14700
14701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14703 if (SWIG_arg_fail(1)) SWIG_fail;
14704 if (obj1) {
14705 {
14706 arg2 = wxString_in_helper(obj1);
14707 if (arg2 == NULL) SWIG_fail;
14708 temp2 = true;
14709 }
14710 }
14711 if (obj2) {
14712 {
14713 arg3 = (int)(SWIG_As_int(obj2));
14714 if (SWIG_arg_fail(3)) SWIG_fail;
14715 }
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14720
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 {
14725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14726 }
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 return resultobj;
14732 fail:
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 return NULL;
14738 }
14739
14740
14741 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj;
14743 wxFileType *arg1 = (wxFileType *) 0 ;
14744 bool result;
14745 PyObject * obj0 = 0 ;
14746 char *kwnames[] = {
14747 (char *) "self", NULL
14748 };
14749
14750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(1)) SWIG_fail;
14753 {
14754 PyThreadState* __tstate = wxPyBeginAllowThreads();
14755 result = (bool)(arg1)->Unassociate();
14756
14757 wxPyEndAllowThreads(__tstate);
14758 if (PyErr_Occurred()) SWIG_fail;
14759 }
14760 {
14761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14762 }
14763 return resultobj;
14764 fail:
14765 return NULL;
14766 }
14767
14768
14769 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14770 PyObject *resultobj;
14771 wxString *arg1 = 0 ;
14772 wxString *arg2 = 0 ;
14773 wxString const &arg3_defvalue = wxPyEmptyString ;
14774 wxString *arg3 = (wxString *) &arg3_defvalue ;
14775 wxString result;
14776 bool temp1 = false ;
14777 bool temp2 = false ;
14778 bool temp3 = false ;
14779 PyObject * obj0 = 0 ;
14780 PyObject * obj1 = 0 ;
14781 PyObject * obj2 = 0 ;
14782 char *kwnames[] = {
14783 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14784 };
14785
14786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14787 {
14788 arg1 = wxString_in_helper(obj0);
14789 if (arg1 == NULL) SWIG_fail;
14790 temp1 = true;
14791 }
14792 {
14793 arg2 = wxString_in_helper(obj1);
14794 if (arg2 == NULL) SWIG_fail;
14795 temp2 = true;
14796 }
14797 if (obj2) {
14798 {
14799 arg3 = wxString_in_helper(obj2);
14800 if (arg3 == NULL) SWIG_fail;
14801 temp3 = true;
14802 }
14803 }
14804 {
14805 PyThreadState* __tstate = wxPyBeginAllowThreads();
14806 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14807
14808 wxPyEndAllowThreads(__tstate);
14809 if (PyErr_Occurred()) SWIG_fail;
14810 }
14811 {
14812 #if wxUSE_UNICODE
14813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14814 #else
14815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14816 #endif
14817 }
14818 {
14819 if (temp1)
14820 delete arg1;
14821 }
14822 {
14823 if (temp2)
14824 delete arg2;
14825 }
14826 {
14827 if (temp3)
14828 delete arg3;
14829 }
14830 return resultobj;
14831 fail:
14832 {
14833 if (temp1)
14834 delete arg1;
14835 }
14836 {
14837 if (temp2)
14838 delete arg2;
14839 }
14840 {
14841 if (temp3)
14842 delete arg3;
14843 }
14844 return NULL;
14845 }
14846
14847
14848 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14849 PyObject *obj;
14850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14851 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14852 Py_INCREF(obj);
14853 return Py_BuildValue((char *)"");
14854 }
14855 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14856 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14857 return 1;
14858 }
14859
14860
14861 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14862 PyObject *pyobj;
14863
14864 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14865 return pyobj;
14866 }
14867
14868
14869 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj;
14871 wxString *arg1 = 0 ;
14872 wxString *arg2 = 0 ;
14873 bool result;
14874 bool temp1 = false ;
14875 bool temp2 = false ;
14876 PyObject * obj0 = 0 ;
14877 PyObject * obj1 = 0 ;
14878 char *kwnames[] = {
14879 (char *) "mimeType",(char *) "wildcard", NULL
14880 };
14881
14882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14883 {
14884 arg1 = wxString_in_helper(obj0);
14885 if (arg1 == NULL) SWIG_fail;
14886 temp1 = true;
14887 }
14888 {
14889 arg2 = wxString_in_helper(obj1);
14890 if (arg2 == NULL) SWIG_fail;
14891 temp2 = true;
14892 }
14893 {
14894 PyThreadState* __tstate = wxPyBeginAllowThreads();
14895 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14896
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 {
14901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14902 }
14903 {
14904 if (temp1)
14905 delete arg1;
14906 }
14907 {
14908 if (temp2)
14909 delete arg2;
14910 }
14911 return resultobj;
14912 fail:
14913 {
14914 if (temp1)
14915 delete arg1;
14916 }
14917 {
14918 if (temp2)
14919 delete arg2;
14920 }
14921 return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj;
14927 wxMimeTypesManager *result;
14928 char *kwnames[] = {
14929 NULL
14930 };
14931
14932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14936
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14948 PyObject *resultobj;
14949 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14950 int arg2 = (int) wxMAILCAP_ALL ;
14951 wxString const &arg3_defvalue = wxPyEmptyString ;
14952 wxString *arg3 = (wxString *) &arg3_defvalue ;
14953 bool temp3 = false ;
14954 PyObject * obj0 = 0 ;
14955 PyObject * obj1 = 0 ;
14956 PyObject * obj2 = 0 ;
14957 char *kwnames[] = {
14958 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14959 };
14960
14961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14963 if (SWIG_arg_fail(1)) SWIG_fail;
14964 if (obj1) {
14965 {
14966 arg2 = (int)(SWIG_As_int(obj1));
14967 if (SWIG_arg_fail(2)) SWIG_fail;
14968 }
14969 }
14970 if (obj2) {
14971 {
14972 arg3 = wxString_in_helper(obj2);
14973 if (arg3 == NULL) SWIG_fail;
14974 temp3 = true;
14975 }
14976 }
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 Py_INCREF(Py_None); resultobj = Py_None;
14985 {
14986 if (temp3)
14987 delete arg3;
14988 }
14989 return resultobj;
14990 fail:
14991 {
14992 if (temp3)
14993 delete arg3;
14994 }
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15002 PyObject * obj0 = 0 ;
15003 char *kwnames[] = {
15004 (char *) "self", NULL
15005 };
15006
15007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15009 if (SWIG_arg_fail(1)) SWIG_fail;
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 (arg1)->ClearData();
15013
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 Py_INCREF(Py_None); resultobj = Py_None;
15018 return resultobj;
15019 fail:
15020 return NULL;
15021 }
15022
15023
15024 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj;
15026 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15027 wxString *arg2 = 0 ;
15028 wxFileType *result;
15029 bool temp2 = false ;
15030 PyObject * obj0 = 0 ;
15031 PyObject * obj1 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self",(char *) "ext", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 arg2 = wxString_in_helper(obj1);
15041 if (arg2 == NULL) SWIG_fail;
15042 temp2 = true;
15043 }
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15047
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15052 {
15053 if (temp2)
15054 delete arg2;
15055 }
15056 return resultobj;
15057 fail:
15058 {
15059 if (temp2)
15060 delete arg2;
15061 }
15062 return NULL;
15063 }
15064
15065
15066 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15069 wxString *arg2 = 0 ;
15070 wxFileType *result;
15071 bool temp2 = false ;
15072 PyObject * obj0 = 0 ;
15073 PyObject * obj1 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self",(char *) "mimeType", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 {
15082 arg2 = wxString_in_helper(obj1);
15083 if (arg2 == NULL) SWIG_fail;
15084 temp2 = true;
15085 }
15086 {
15087 PyThreadState* __tstate = wxPyBeginAllowThreads();
15088 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15089
15090 wxPyEndAllowThreads(__tstate);
15091 if (PyErr_Occurred()) SWIG_fail;
15092 }
15093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15094 {
15095 if (temp2)
15096 delete arg2;
15097 }
15098 return resultobj;
15099 fail:
15100 {
15101 if (temp2)
15102 delete arg2;
15103 }
15104 return NULL;
15105 }
15106
15107
15108 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj;
15110 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15111 wxString *arg2 = 0 ;
15112 bool arg3 = (bool) false ;
15113 bool result;
15114 bool temp2 = false ;
15115 PyObject * obj0 = 0 ;
15116 PyObject * obj1 = 0 ;
15117 PyObject * obj2 = 0 ;
15118 char *kwnames[] = {
15119 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15120 };
15121
15122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15124 if (SWIG_arg_fail(1)) SWIG_fail;
15125 {
15126 arg2 = wxString_in_helper(obj1);
15127 if (arg2 == NULL) SWIG_fail;
15128 temp2 = true;
15129 }
15130 if (obj2) {
15131 {
15132 arg3 = (bool)(SWIG_As_bool(obj2));
15133 if (SWIG_arg_fail(3)) SWIG_fail;
15134 }
15135 }
15136 {
15137 PyThreadState* __tstate = wxPyBeginAllowThreads();
15138 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15139
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 {
15144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15145 }
15146 {
15147 if (temp2)
15148 delete arg2;
15149 }
15150 return resultobj;
15151 fail:
15152 {
15153 if (temp2)
15154 delete arg2;
15155 }
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15163 wxString *arg2 = 0 ;
15164 bool result;
15165 bool temp2 = false ;
15166 PyObject * obj0 = 0 ;
15167 PyObject * obj1 = 0 ;
15168 char *kwnames[] = {
15169 (char *) "self",(char *) "filename", NULL
15170 };
15171
15172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15174 if (SWIG_arg_fail(1)) SWIG_fail;
15175 {
15176 arg2 = wxString_in_helper(obj1);
15177 if (arg2 == NULL) SWIG_fail;
15178 temp2 = true;
15179 }
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15183
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 {
15188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15189 }
15190 {
15191 if (temp2)
15192 delete arg2;
15193 }
15194 return resultobj;
15195 fail:
15196 {
15197 if (temp2)
15198 delete arg2;
15199 }
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15207 PyObject *result;
15208 PyObject * obj0 = 0 ;
15209 char *kwnames[] = {
15210 (char *) "self", NULL
15211 };
15212
15213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15215 if (SWIG_arg_fail(1)) SWIG_fail;
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 resultobj = result;
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15231 PyObject *resultobj;
15232 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15233 wxFileTypeInfo *arg2 = 0 ;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "self",(char *) "ft", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 {
15244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15245 if (SWIG_arg_fail(2)) SWIG_fail;
15246 if (arg2 == NULL) {
15247 SWIG_null_ref("wxFileTypeInfo");
15248 }
15249 if (SWIG_arg_fail(2)) SWIG_fail;
15250 }
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15254
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 Py_INCREF(Py_None); resultobj = Py_None;
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15266 PyObject *resultobj;
15267 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15268 wxFileTypeInfo *arg2 = 0 ;
15269 wxFileType *result;
15270 PyObject * obj0 = 0 ;
15271 PyObject * obj1 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self",(char *) "ftInfo", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15281 if (SWIG_arg_fail(2)) SWIG_fail;
15282 if (arg2 == NULL) {
15283 SWIG_null_ref("wxFileTypeInfo");
15284 }
15285 if (SWIG_arg_fail(2)) SWIG_fail;
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15304 wxFileType *arg2 = (wxFileType *) 0 ;
15305 bool result;
15306 PyObject * obj0 = 0 ;
15307 PyObject * obj1 = 0 ;
15308 char *kwnames[] = {
15309 (char *) "self",(char *) "ft", NULL
15310 };
15311
15312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15314 if (SWIG_arg_fail(1)) SWIG_fail;
15315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15316 if (SWIG_arg_fail(2)) SWIG_fail;
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (bool)(arg1)->Unassociate(arg2);
15320
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 {
15325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15326 }
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj;
15335 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15336 PyObject * obj0 = 0 ;
15337 char *kwnames[] = {
15338 (char *) "self", NULL
15339 };
15340
15341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15343 if (SWIG_arg_fail(1)) SWIG_fail;
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 delete arg1;
15347
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 Py_INCREF(Py_None); resultobj = Py_None;
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15359 PyObject *obj;
15360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15361 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15362 Py_INCREF(obj);
15363 return Py_BuildValue((char *)"");
15364 }
15365 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15366 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15367 return 1;
15368 }
15369
15370
15371 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15372 PyObject *pyobj;
15373
15374 {
15375 #if wxUSE_UNICODE
15376 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15377 #else
15378 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15379 #endif
15380 }
15381 return pyobj;
15382 }
15383
15384
15385 static int _wrap_ART_MENU_set(PyObject *) {
15386 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15387 return 1;
15388 }
15389
15390
15391 static PyObject *_wrap_ART_MENU_get(void) {
15392 PyObject *pyobj;
15393
15394 {
15395 #if wxUSE_UNICODE
15396 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15397 #else
15398 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15399 #endif
15400 }
15401 return pyobj;
15402 }
15403
15404
15405 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15406 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15407 return 1;
15408 }
15409
15410
15411 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15412 PyObject *pyobj;
15413
15414 {
15415 #if wxUSE_UNICODE
15416 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15417 #else
15418 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15419 #endif
15420 }
15421 return pyobj;
15422 }
15423
15424
15425 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15426 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15427 return 1;
15428 }
15429
15430
15431 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15432 PyObject *pyobj;
15433
15434 {
15435 #if wxUSE_UNICODE
15436 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15437 #else
15438 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15439 #endif
15440 }
15441 return pyobj;
15442 }
15443
15444
15445 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15446 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15447 return 1;
15448 }
15449
15450
15451 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15452 PyObject *pyobj;
15453
15454 {
15455 #if wxUSE_UNICODE
15456 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15457 #else
15458 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15459 #endif
15460 }
15461 return pyobj;
15462 }
15463
15464
15465 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15466 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15467 return 1;
15468 }
15469
15470
15471 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15472 PyObject *pyobj;
15473
15474 {
15475 #if wxUSE_UNICODE
15476 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15477 #else
15478 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15479 #endif
15480 }
15481 return pyobj;
15482 }
15483
15484
15485 static int _wrap_ART_BUTTON_set(PyObject *) {
15486 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15487 return 1;
15488 }
15489
15490
15491 static PyObject *_wrap_ART_BUTTON_get(void) {
15492 PyObject *pyobj;
15493
15494 {
15495 #if wxUSE_UNICODE
15496 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15497 #else
15498 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15499 #endif
15500 }
15501 return pyobj;
15502 }
15503
15504
15505 static int _wrap_ART_OTHER_set(PyObject *) {
15506 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15507 return 1;
15508 }
15509
15510
15511 static PyObject *_wrap_ART_OTHER_get(void) {
15512 PyObject *pyobj;
15513
15514 {
15515 #if wxUSE_UNICODE
15516 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15517 #else
15518 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15519 #endif
15520 }
15521 return pyobj;
15522 }
15523
15524
15525 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15526 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15527 return 1;
15528 }
15529
15530
15531 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15532 PyObject *pyobj;
15533
15534 {
15535 #if wxUSE_UNICODE
15536 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15537 #else
15538 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15539 #endif
15540 }
15541 return pyobj;
15542 }
15543
15544
15545 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15546 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15547 return 1;
15548 }
15549
15550
15551 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15552 PyObject *pyobj;
15553
15554 {
15555 #if wxUSE_UNICODE
15556 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15557 #else
15558 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15559 #endif
15560 }
15561 return pyobj;
15562 }
15563
15564
15565 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15566 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15567 return 1;
15568 }
15569
15570
15571 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15572 PyObject *pyobj;
15573
15574 {
15575 #if wxUSE_UNICODE
15576 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15577 #else
15578 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15579 #endif
15580 }
15581 return pyobj;
15582 }
15583
15584
15585 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15586 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15587 return 1;
15588 }
15589
15590
15591 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15592 PyObject *pyobj;
15593
15594 {
15595 #if wxUSE_UNICODE
15596 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15597 #else
15598 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15599 #endif
15600 }
15601 return pyobj;
15602 }
15603
15604
15605 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15606 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15607 return 1;
15608 }
15609
15610
15611 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15612 PyObject *pyobj;
15613
15614 {
15615 #if wxUSE_UNICODE
15616 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15617 #else
15618 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15619 #endif
15620 }
15621 return pyobj;
15622 }
15623
15624
15625 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15626 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15627 return 1;
15628 }
15629
15630
15631 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15632 PyObject *pyobj;
15633
15634 {
15635 #if wxUSE_UNICODE
15636 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15637 #else
15638 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15639 #endif
15640 }
15641 return pyobj;
15642 }
15643
15644
15645 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15646 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15647 return 1;
15648 }
15649
15650
15651 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15652 PyObject *pyobj;
15653
15654 {
15655 #if wxUSE_UNICODE
15656 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15657 #else
15658 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15659 #endif
15660 }
15661 return pyobj;
15662 }
15663
15664
15665 static int _wrap_ART_GO_BACK_set(PyObject *) {
15666 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15667 return 1;
15668 }
15669
15670
15671 static PyObject *_wrap_ART_GO_BACK_get(void) {
15672 PyObject *pyobj;
15673
15674 {
15675 #if wxUSE_UNICODE
15676 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15677 #else
15678 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15679 #endif
15680 }
15681 return pyobj;
15682 }
15683
15684
15685 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15686 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15687 return 1;
15688 }
15689
15690
15691 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15692 PyObject *pyobj;
15693
15694 {
15695 #if wxUSE_UNICODE
15696 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15697 #else
15698 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15699 #endif
15700 }
15701 return pyobj;
15702 }
15703
15704
15705 static int _wrap_ART_GO_UP_set(PyObject *) {
15706 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15707 return 1;
15708 }
15709
15710
15711 static PyObject *_wrap_ART_GO_UP_get(void) {
15712 PyObject *pyobj;
15713
15714 {
15715 #if wxUSE_UNICODE
15716 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15717 #else
15718 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15719 #endif
15720 }
15721 return pyobj;
15722 }
15723
15724
15725 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15726 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15727 return 1;
15728 }
15729
15730
15731 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15732 PyObject *pyobj;
15733
15734 {
15735 #if wxUSE_UNICODE
15736 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15737 #else
15738 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15739 #endif
15740 }
15741 return pyobj;
15742 }
15743
15744
15745 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15746 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15747 return 1;
15748 }
15749
15750
15751 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15752 PyObject *pyobj;
15753
15754 {
15755 #if wxUSE_UNICODE
15756 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15757 #else
15758 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15759 #endif
15760 }
15761 return pyobj;
15762 }
15763
15764
15765 static int _wrap_ART_GO_HOME_set(PyObject *) {
15766 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15767 return 1;
15768 }
15769
15770
15771 static PyObject *_wrap_ART_GO_HOME_get(void) {
15772 PyObject *pyobj;
15773
15774 {
15775 #if wxUSE_UNICODE
15776 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15777 #else
15778 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15779 #endif
15780 }
15781 return pyobj;
15782 }
15783
15784
15785 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15786 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15787 return 1;
15788 }
15789
15790
15791 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15792 PyObject *pyobj;
15793
15794 {
15795 #if wxUSE_UNICODE
15796 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15797 #else
15798 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15799 #endif
15800 }
15801 return pyobj;
15802 }
15803
15804
15805 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15806 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15807 return 1;
15808 }
15809
15810
15811 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15812 PyObject *pyobj;
15813
15814 {
15815 #if wxUSE_UNICODE
15816 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15817 #else
15818 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15819 #endif
15820 }
15821 return pyobj;
15822 }
15823
15824
15825 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15826 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15827 return 1;
15828 }
15829
15830
15831 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15832 PyObject *pyobj;
15833
15834 {
15835 #if wxUSE_UNICODE
15836 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15837 #else
15838 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15839 #endif
15840 }
15841 return pyobj;
15842 }
15843
15844
15845 static int _wrap_ART_PRINT_set(PyObject *) {
15846 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15847 return 1;
15848 }
15849
15850
15851 static PyObject *_wrap_ART_PRINT_get(void) {
15852 PyObject *pyobj;
15853
15854 {
15855 #if wxUSE_UNICODE
15856 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15857 #else
15858 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15859 #endif
15860 }
15861 return pyobj;
15862 }
15863
15864
15865 static int _wrap_ART_HELP_set(PyObject *) {
15866 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15867 return 1;
15868 }
15869
15870
15871 static PyObject *_wrap_ART_HELP_get(void) {
15872 PyObject *pyobj;
15873
15874 {
15875 #if wxUSE_UNICODE
15876 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15877 #else
15878 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15879 #endif
15880 }
15881 return pyobj;
15882 }
15883
15884
15885 static int _wrap_ART_TIP_set(PyObject *) {
15886 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15887 return 1;
15888 }
15889
15890
15891 static PyObject *_wrap_ART_TIP_get(void) {
15892 PyObject *pyobj;
15893
15894 {
15895 #if wxUSE_UNICODE
15896 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15897 #else
15898 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15899 #endif
15900 }
15901 return pyobj;
15902 }
15903
15904
15905 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15906 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15907 return 1;
15908 }
15909
15910
15911 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15912 PyObject *pyobj;
15913
15914 {
15915 #if wxUSE_UNICODE
15916 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15917 #else
15918 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15919 #endif
15920 }
15921 return pyobj;
15922 }
15923
15924
15925 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15926 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15927 return 1;
15928 }
15929
15930
15931 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15932 PyObject *pyobj;
15933
15934 {
15935 #if wxUSE_UNICODE
15936 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15937 #else
15938 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15939 #endif
15940 }
15941 return pyobj;
15942 }
15943
15944
15945 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15946 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15947 return 1;
15948 }
15949
15950
15951 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15952 PyObject *pyobj;
15953
15954 {
15955 #if wxUSE_UNICODE
15956 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15957 #else
15958 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15959 #endif
15960 }
15961 return pyobj;
15962 }
15963
15964
15965 static int _wrap_ART_HARDDISK_set(PyObject *) {
15966 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15967 return 1;
15968 }
15969
15970
15971 static PyObject *_wrap_ART_HARDDISK_get(void) {
15972 PyObject *pyobj;
15973
15974 {
15975 #if wxUSE_UNICODE
15976 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15977 #else
15978 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15979 #endif
15980 }
15981 return pyobj;
15982 }
15983
15984
15985 static int _wrap_ART_FLOPPY_set(PyObject *) {
15986 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15987 return 1;
15988 }
15989
15990
15991 static PyObject *_wrap_ART_FLOPPY_get(void) {
15992 PyObject *pyobj;
15993
15994 {
15995 #if wxUSE_UNICODE
15996 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15997 #else
15998 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15999 #endif
16000 }
16001 return pyobj;
16002 }
16003
16004
16005 static int _wrap_ART_CDROM_set(PyObject *) {
16006 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16007 return 1;
16008 }
16009
16010
16011 static PyObject *_wrap_ART_CDROM_get(void) {
16012 PyObject *pyobj;
16013
16014 {
16015 #if wxUSE_UNICODE
16016 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16017 #else
16018 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16019 #endif
16020 }
16021 return pyobj;
16022 }
16023
16024
16025 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16026 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16027 return 1;
16028 }
16029
16030
16031 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16032 PyObject *pyobj;
16033
16034 {
16035 #if wxUSE_UNICODE
16036 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16037 #else
16038 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16039 #endif
16040 }
16041 return pyobj;
16042 }
16043
16044
16045 static int _wrap_ART_FOLDER_set(PyObject *) {
16046 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16047 return 1;
16048 }
16049
16050
16051 static PyObject *_wrap_ART_FOLDER_get(void) {
16052 PyObject *pyobj;
16053
16054 {
16055 #if wxUSE_UNICODE
16056 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16057 #else
16058 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16059 #endif
16060 }
16061 return pyobj;
16062 }
16063
16064
16065 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16066 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16067 return 1;
16068 }
16069
16070
16071 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16072 PyObject *pyobj;
16073
16074 {
16075 #if wxUSE_UNICODE
16076 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16077 #else
16078 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16079 #endif
16080 }
16081 return pyobj;
16082 }
16083
16084
16085 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16086 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16087 return 1;
16088 }
16089
16090
16091 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16092 PyObject *pyobj;
16093
16094 {
16095 #if wxUSE_UNICODE
16096 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16097 #else
16098 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16099 #endif
16100 }
16101 return pyobj;
16102 }
16103
16104
16105 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16106 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16107 return 1;
16108 }
16109
16110
16111 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16112 PyObject *pyobj;
16113
16114 {
16115 #if wxUSE_UNICODE
16116 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16117 #else
16118 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16119 #endif
16120 }
16121 return pyobj;
16122 }
16123
16124
16125 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16126 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16127 return 1;
16128 }
16129
16130
16131 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16132 PyObject *pyobj;
16133
16134 {
16135 #if wxUSE_UNICODE
16136 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16137 #else
16138 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16139 #endif
16140 }
16141 return pyobj;
16142 }
16143
16144
16145 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16146 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16147 return 1;
16148 }
16149
16150
16151 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16152 PyObject *pyobj;
16153
16154 {
16155 #if wxUSE_UNICODE
16156 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16157 #else
16158 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16159 #endif
16160 }
16161 return pyobj;
16162 }
16163
16164
16165 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16166 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16167 return 1;
16168 }
16169
16170
16171 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16172 PyObject *pyobj;
16173
16174 {
16175 #if wxUSE_UNICODE
16176 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16177 #else
16178 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16179 #endif
16180 }
16181 return pyobj;
16182 }
16183
16184
16185 static int _wrap_ART_ERROR_set(PyObject *) {
16186 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16187 return 1;
16188 }
16189
16190
16191 static PyObject *_wrap_ART_ERROR_get(void) {
16192 PyObject *pyobj;
16193
16194 {
16195 #if wxUSE_UNICODE
16196 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16197 #else
16198 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16199 #endif
16200 }
16201 return pyobj;
16202 }
16203
16204
16205 static int _wrap_ART_QUESTION_set(PyObject *) {
16206 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16207 return 1;
16208 }
16209
16210
16211 static PyObject *_wrap_ART_QUESTION_get(void) {
16212 PyObject *pyobj;
16213
16214 {
16215 #if wxUSE_UNICODE
16216 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16217 #else
16218 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16219 #endif
16220 }
16221 return pyobj;
16222 }
16223
16224
16225 static int _wrap_ART_WARNING_set(PyObject *) {
16226 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16227 return 1;
16228 }
16229
16230
16231 static PyObject *_wrap_ART_WARNING_get(void) {
16232 PyObject *pyobj;
16233
16234 {
16235 #if wxUSE_UNICODE
16236 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16237 #else
16238 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16239 #endif
16240 }
16241 return pyobj;
16242 }
16243
16244
16245 static int _wrap_ART_INFORMATION_set(PyObject *) {
16246 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16247 return 1;
16248 }
16249
16250
16251 static PyObject *_wrap_ART_INFORMATION_get(void) {
16252 PyObject *pyobj;
16253
16254 {
16255 #if wxUSE_UNICODE
16256 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16257 #else
16258 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16259 #endif
16260 }
16261 return pyobj;
16262 }
16263
16264
16265 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16266 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16267 return 1;
16268 }
16269
16270
16271 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16272 PyObject *pyobj;
16273
16274 {
16275 #if wxUSE_UNICODE
16276 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16277 #else
16278 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16279 #endif
16280 }
16281 return pyobj;
16282 }
16283
16284
16285 static int _wrap_ART_COPY_set(PyObject *) {
16286 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16287 return 1;
16288 }
16289
16290
16291 static PyObject *_wrap_ART_COPY_get(void) {
16292 PyObject *pyobj;
16293
16294 {
16295 #if wxUSE_UNICODE
16296 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16297 #else
16298 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16299 #endif
16300 }
16301 return pyobj;
16302 }
16303
16304
16305 static int _wrap_ART_CUT_set(PyObject *) {
16306 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16307 return 1;
16308 }
16309
16310
16311 static PyObject *_wrap_ART_CUT_get(void) {
16312 PyObject *pyobj;
16313
16314 {
16315 #if wxUSE_UNICODE
16316 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16317 #else
16318 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16319 #endif
16320 }
16321 return pyobj;
16322 }
16323
16324
16325 static int _wrap_ART_PASTE_set(PyObject *) {
16326 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16327 return 1;
16328 }
16329
16330
16331 static PyObject *_wrap_ART_PASTE_get(void) {
16332 PyObject *pyobj;
16333
16334 {
16335 #if wxUSE_UNICODE
16336 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16337 #else
16338 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16339 #endif
16340 }
16341 return pyobj;
16342 }
16343
16344
16345 static int _wrap_ART_DELETE_set(PyObject *) {
16346 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16347 return 1;
16348 }
16349
16350
16351 static PyObject *_wrap_ART_DELETE_get(void) {
16352 PyObject *pyobj;
16353
16354 {
16355 #if wxUSE_UNICODE
16356 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16357 #else
16358 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16359 #endif
16360 }
16361 return pyobj;
16362 }
16363
16364
16365 static int _wrap_ART_UNDO_set(PyObject *) {
16366 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16367 return 1;
16368 }
16369
16370
16371 static PyObject *_wrap_ART_UNDO_get(void) {
16372 PyObject *pyobj;
16373
16374 {
16375 #if wxUSE_UNICODE
16376 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16377 #else
16378 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16379 #endif
16380 }
16381 return pyobj;
16382 }
16383
16384
16385 static int _wrap_ART_REDO_set(PyObject *) {
16386 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16387 return 1;
16388 }
16389
16390
16391 static PyObject *_wrap_ART_REDO_get(void) {
16392 PyObject *pyobj;
16393
16394 {
16395 #if wxUSE_UNICODE
16396 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16397 #else
16398 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16399 #endif
16400 }
16401 return pyobj;
16402 }
16403
16404
16405 static int _wrap_ART_QUIT_set(PyObject *) {
16406 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16407 return 1;
16408 }
16409
16410
16411 static PyObject *_wrap_ART_QUIT_get(void) {
16412 PyObject *pyobj;
16413
16414 {
16415 #if wxUSE_UNICODE
16416 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16417 #else
16418 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16419 #endif
16420 }
16421 return pyobj;
16422 }
16423
16424
16425 static int _wrap_ART_FIND_set(PyObject *) {
16426 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16427 return 1;
16428 }
16429
16430
16431 static PyObject *_wrap_ART_FIND_get(void) {
16432 PyObject *pyobj;
16433
16434 {
16435 #if wxUSE_UNICODE
16436 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16437 #else
16438 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16439 #endif
16440 }
16441 return pyobj;
16442 }
16443
16444
16445 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16446 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16447 return 1;
16448 }
16449
16450
16451 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16452 PyObject *pyobj;
16453
16454 {
16455 #if wxUSE_UNICODE
16456 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16457 #else
16458 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16459 #endif
16460 }
16461 return pyobj;
16462 }
16463
16464
16465 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj;
16467 wxPyArtProvider *result;
16468 char *kwnames[] = {
16469 NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16473 {
16474 if (!wxPyCheckForApp()) SWIG_fail;
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 result = (wxPyArtProvider *)new wxPyArtProvider();
16477
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16482 return resultobj;
16483 fail:
16484 return NULL;
16485 }
16486
16487
16488 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16489 PyObject *resultobj;
16490 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16491 PyObject *arg2 = (PyObject *) 0 ;
16492 PyObject *arg3 = (PyObject *) 0 ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 PyObject * obj2 = 0 ;
16496 char *kwnames[] = {
16497 (char *) "self",(char *) "self",(char *) "_class", NULL
16498 };
16499
16500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16502 if (SWIG_arg_fail(1)) SWIG_fail;
16503 arg2 = obj1;
16504 arg3 = obj2;
16505 {
16506 PyThreadState* __tstate = wxPyBeginAllowThreads();
16507 (arg1)->_setCallbackInfo(arg2,arg3);
16508
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 Py_INCREF(Py_None); resultobj = Py_None;
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16522 PyObject * obj0 = 0 ;
16523 char *kwnames[] = {
16524 (char *) "provider", NULL
16525 };
16526
16527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16529 if (SWIG_arg_fail(1)) SWIG_fail;
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 wxPyArtProvider::PushProvider(arg1);
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 Py_INCREF(Py_None); resultobj = Py_None;
16538 return resultobj;
16539 fail:
16540 return NULL;
16541 }
16542
16543
16544 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj;
16546 bool result;
16547 char *kwnames[] = {
16548 NULL
16549 };
16550
16551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 result = (bool)wxPyArtProvider::PopProvider();
16555
16556 wxPyEndAllowThreads(__tstate);
16557 if (PyErr_Occurred()) SWIG_fail;
16558 }
16559 {
16560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16561 }
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj;
16570 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16571 bool result;
16572 PyObject * obj0 = 0 ;
16573 char *kwnames[] = {
16574 (char *) "provider", NULL
16575 };
16576
16577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16579 if (SWIG_arg_fail(1)) SWIG_fail;
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16583
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxString *arg1 = 0 ;
16599 wxString const &arg2_defvalue = wxPyART_OTHER ;
16600 wxString *arg2 = (wxString *) &arg2_defvalue ;
16601 wxSize const &arg3_defvalue = wxDefaultSize ;
16602 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16603 wxBitmap result;
16604 bool temp1 = false ;
16605 bool temp2 = false ;
16606 wxSize temp3 ;
16607 PyObject * obj0 = 0 ;
16608 PyObject * obj1 = 0 ;
16609 PyObject * obj2 = 0 ;
16610 char *kwnames[] = {
16611 (char *) "id",(char *) "client",(char *) "size", NULL
16612 };
16613
16614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16615 {
16616 arg1 = wxString_in_helper(obj0);
16617 if (arg1 == NULL) SWIG_fail;
16618 temp1 = true;
16619 }
16620 if (obj1) {
16621 {
16622 arg2 = wxString_in_helper(obj1);
16623 if (arg2 == NULL) SWIG_fail;
16624 temp2 = true;
16625 }
16626 }
16627 if (obj2) {
16628 {
16629 arg3 = &temp3;
16630 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16631 }
16632 }
16633 {
16634 if (!wxPyCheckForApp()) SWIG_fail;
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 wxBitmap * resultptr;
16643 resultptr = new wxBitmap((wxBitmap &)(result));
16644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16645 }
16646 {
16647 if (temp1)
16648 delete arg1;
16649 }
16650 {
16651 if (temp2)
16652 delete arg2;
16653 }
16654 return resultobj;
16655 fail:
16656 {
16657 if (temp1)
16658 delete arg1;
16659 }
16660 {
16661 if (temp2)
16662 delete arg2;
16663 }
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxString *arg1 = 0 ;
16671 wxString const &arg2_defvalue = wxPyART_OTHER ;
16672 wxString *arg2 = (wxString *) &arg2_defvalue ;
16673 wxSize const &arg3_defvalue = wxDefaultSize ;
16674 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16675 wxIcon result;
16676 bool temp1 = false ;
16677 bool temp2 = false ;
16678 wxSize temp3 ;
16679 PyObject * obj0 = 0 ;
16680 PyObject * obj1 = 0 ;
16681 PyObject * obj2 = 0 ;
16682 char *kwnames[] = {
16683 (char *) "id",(char *) "client",(char *) "size", NULL
16684 };
16685
16686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16687 {
16688 arg1 = wxString_in_helper(obj0);
16689 if (arg1 == NULL) SWIG_fail;
16690 temp1 = true;
16691 }
16692 if (obj1) {
16693 {
16694 arg2 = wxString_in_helper(obj1);
16695 if (arg2 == NULL) SWIG_fail;
16696 temp2 = true;
16697 }
16698 }
16699 if (obj2) {
16700 {
16701 arg3 = &temp3;
16702 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16703 }
16704 }
16705 {
16706 if (!wxPyCheckForApp()) SWIG_fail;
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 wxIcon * resultptr;
16715 resultptr = new wxIcon((wxIcon &)(result));
16716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16717 }
16718 {
16719 if (temp1)
16720 delete arg1;
16721 }
16722 {
16723 if (temp2)
16724 delete arg2;
16725 }
16726 return resultobj;
16727 fail:
16728 {
16729 if (temp1)
16730 delete arg1;
16731 }
16732 {
16733 if (temp2)
16734 delete arg2;
16735 }
16736 return NULL;
16737 }
16738
16739
16740 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16741 PyObject *resultobj;
16742 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16743 PyObject * obj0 = 0 ;
16744 char *kwnames[] = {
16745 (char *) "self", NULL
16746 };
16747
16748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16750 if (SWIG_arg_fail(1)) SWIG_fail;
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 wxPyArtProvider_Destroy(arg1);
16754
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 Py_INCREF(Py_None); resultobj = Py_None;
16759 return resultobj;
16760 fail:
16761 return NULL;
16762 }
16763
16764
16765 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16766 PyObject *obj;
16767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16768 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16769 Py_INCREF(obj);
16770 return Py_BuildValue((char *)"");
16771 }
16772 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16773 PyObject *resultobj;
16774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16775 PyObject * obj0 = 0 ;
16776 char *kwnames[] = {
16777 (char *) "self", NULL
16778 };
16779
16780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16782 if (SWIG_arg_fail(1)) SWIG_fail;
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 delete arg1;
16786
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 Py_INCREF(Py_None); resultobj = Py_None;
16791 return resultobj;
16792 fail:
16793 return NULL;
16794 }
16795
16796
16797 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj;
16799 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16800 wxConfigBase *result;
16801 PyObject * obj0 = 0 ;
16802 char *kwnames[] = {
16803 (char *) "config", NULL
16804 };
16805
16806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16808 if (SWIG_arg_fail(1)) SWIG_fail;
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16812
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16817 return resultobj;
16818 fail:
16819 return NULL;
16820 }
16821
16822
16823 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj;
16825 bool arg1 = (bool) true ;
16826 wxConfigBase *result;
16827 PyObject * obj0 = 0 ;
16828 char *kwnames[] = {
16829 (char *) "createOnDemand", NULL
16830 };
16831
16832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16833 if (obj0) {
16834 {
16835 arg1 = (bool)(SWIG_As_bool(obj0));
16836 if (SWIG_arg_fail(1)) SWIG_fail;
16837 }
16838 }
16839 {
16840 PyThreadState* __tstate = wxPyBeginAllowThreads();
16841 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16842
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16847 return resultobj;
16848 fail:
16849 return NULL;
16850 }
16851
16852
16853 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16854 PyObject *resultobj;
16855 wxConfigBase *result;
16856 char *kwnames[] = {
16857 NULL
16858 };
16859
16860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 result = (wxConfigBase *)wxConfigBase::Create();
16864
16865 wxPyEndAllowThreads(__tstate);
16866 if (PyErr_Occurred()) SWIG_fail;
16867 }
16868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16869 return resultobj;
16870 fail:
16871 return NULL;
16872 }
16873
16874
16875 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16876 PyObject *resultobj;
16877 char *kwnames[] = {
16878 NULL
16879 };
16880
16881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16882 {
16883 PyThreadState* __tstate = wxPyBeginAllowThreads();
16884 wxConfigBase::DontCreateOnDemand();
16885
16886 wxPyEndAllowThreads(__tstate);
16887 if (PyErr_Occurred()) SWIG_fail;
16888 }
16889 Py_INCREF(Py_None); resultobj = Py_None;
16890 return resultobj;
16891 fail:
16892 return NULL;
16893 }
16894
16895
16896 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16897 PyObject *resultobj;
16898 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16899 wxString *arg2 = 0 ;
16900 bool temp2 = false ;
16901 PyObject * obj0 = 0 ;
16902 PyObject * obj1 = 0 ;
16903 char *kwnames[] = {
16904 (char *) "self",(char *) "path", NULL
16905 };
16906
16907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16909 if (SWIG_arg_fail(1)) SWIG_fail;
16910 {
16911 arg2 = wxString_in_helper(obj1);
16912 if (arg2 == NULL) SWIG_fail;
16913 temp2 = true;
16914 }
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 (arg1)->SetPath((wxString const &)*arg2);
16918
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 Py_INCREF(Py_None); resultobj = Py_None;
16923 {
16924 if (temp2)
16925 delete arg2;
16926 }
16927 return resultobj;
16928 fail:
16929 {
16930 if (temp2)
16931 delete arg2;
16932 }
16933 return NULL;
16934 }
16935
16936
16937 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj;
16939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16940 wxString *result;
16941 PyObject * obj0 = 0 ;
16942 char *kwnames[] = {
16943 (char *) "self", NULL
16944 };
16945
16946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16948 if (SWIG_arg_fail(1)) SWIG_fail;
16949 {
16950 PyThreadState* __tstate = wxPyBeginAllowThreads();
16951 {
16952 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16953 result = (wxString *) &_result_ref;
16954 }
16955
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 {
16960 #if wxUSE_UNICODE
16961 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16962 #else
16963 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16964 #endif
16965 }
16966 return resultobj;
16967 fail:
16968 return NULL;
16969 }
16970
16971
16972 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16973 PyObject *resultobj;
16974 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16975 PyObject *result;
16976 PyObject * obj0 = 0 ;
16977 char *kwnames[] = {
16978 (char *) "self", NULL
16979 };
16980
16981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16983 if (SWIG_arg_fail(1)) SWIG_fail;
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16987
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 resultobj = result;
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj;
17000 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17001 long arg2 ;
17002 PyObject *result;
17003 PyObject * obj0 = 0 ;
17004 PyObject * obj1 = 0 ;
17005 char *kwnames[] = {
17006 (char *) "self",(char *) "index", NULL
17007 };
17008
17009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17011 if (SWIG_arg_fail(1)) SWIG_fail;
17012 {
17013 arg2 = (long)(SWIG_As_long(obj1));
17014 if (SWIG_arg_fail(2)) SWIG_fail;
17015 }
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17019
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 resultobj = result;
17024 return resultobj;
17025 fail:
17026 return NULL;
17027 }
17028
17029
17030 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17031 PyObject *resultobj;
17032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17033 PyObject *result;
17034 PyObject * obj0 = 0 ;
17035 char *kwnames[] = {
17036 (char *) "self", NULL
17037 };
17038
17039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17041 if (SWIG_arg_fail(1)) SWIG_fail;
17042 {
17043 PyThreadState* __tstate = wxPyBeginAllowThreads();
17044 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17045
17046 wxPyEndAllowThreads(__tstate);
17047 if (PyErr_Occurred()) SWIG_fail;
17048 }
17049 resultobj = result;
17050 return resultobj;
17051 fail:
17052 return NULL;
17053 }
17054
17055
17056 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17057 PyObject *resultobj;
17058 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17059 long arg2 ;
17060 PyObject *result;
17061 PyObject * obj0 = 0 ;
17062 PyObject * obj1 = 0 ;
17063 char *kwnames[] = {
17064 (char *) "self",(char *) "index", NULL
17065 };
17066
17067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17069 if (SWIG_arg_fail(1)) SWIG_fail;
17070 {
17071 arg2 = (long)(SWIG_As_long(obj1));
17072 if (SWIG_arg_fail(2)) SWIG_fail;
17073 }
17074 {
17075 PyThreadState* __tstate = wxPyBeginAllowThreads();
17076 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17077
17078 wxPyEndAllowThreads(__tstate);
17079 if (PyErr_Occurred()) SWIG_fail;
17080 }
17081 resultobj = result;
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj;
17090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17091 bool arg2 = (bool) false ;
17092 size_t result;
17093 PyObject * obj0 = 0 ;
17094 PyObject * obj1 = 0 ;
17095 char *kwnames[] = {
17096 (char *) "self",(char *) "recursive", NULL
17097 };
17098
17099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17101 if (SWIG_arg_fail(1)) SWIG_fail;
17102 if (obj1) {
17103 {
17104 arg2 = (bool)(SWIG_As_bool(obj1));
17105 if (SWIG_arg_fail(2)) SWIG_fail;
17106 }
17107 }
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17111
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 {
17116 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17117 }
17118 return resultobj;
17119 fail:
17120 return NULL;
17121 }
17122
17123
17124 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17125 PyObject *resultobj;
17126 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17127 bool arg2 = (bool) false ;
17128 size_t result;
17129 PyObject * obj0 = 0 ;
17130 PyObject * obj1 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self",(char *) "recursive", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 if (obj1) {
17139 {
17140 arg2 = (bool)(SWIG_As_bool(obj1));
17141 if (SWIG_arg_fail(2)) SWIG_fail;
17142 }
17143 }
17144 {
17145 PyThreadState* __tstate = wxPyBeginAllowThreads();
17146 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17147
17148 wxPyEndAllowThreads(__tstate);
17149 if (PyErr_Occurred()) SWIG_fail;
17150 }
17151 {
17152 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17153 }
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17163 wxString *arg2 = 0 ;
17164 bool result;
17165 bool temp2 = false ;
17166 PyObject * obj0 = 0 ;
17167 PyObject * obj1 = 0 ;
17168 char *kwnames[] = {
17169 (char *) "self",(char *) "name", NULL
17170 };
17171
17172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 {
17176 arg2 = wxString_in_helper(obj1);
17177 if (arg2 == NULL) SWIG_fail;
17178 temp2 = true;
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17183
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 {
17188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17189 }
17190 {
17191 if (temp2)
17192 delete arg2;
17193 }
17194 return resultobj;
17195 fail:
17196 {
17197 if (temp2)
17198 delete arg2;
17199 }
17200 return NULL;
17201 }
17202
17203
17204 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17205 PyObject *resultobj;
17206 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17207 wxString *arg2 = 0 ;
17208 bool result;
17209 bool temp2 = false ;
17210 PyObject * obj0 = 0 ;
17211 PyObject * obj1 = 0 ;
17212 char *kwnames[] = {
17213 (char *) "self",(char *) "name", NULL
17214 };
17215
17216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17218 if (SWIG_arg_fail(1)) SWIG_fail;
17219 {
17220 arg2 = wxString_in_helper(obj1);
17221 if (arg2 == NULL) SWIG_fail;
17222 temp2 = true;
17223 }
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17227
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 {
17232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17233 }
17234 {
17235 if (temp2)
17236 delete arg2;
17237 }
17238 return resultobj;
17239 fail:
17240 {
17241 if (temp2)
17242 delete arg2;
17243 }
17244 return NULL;
17245 }
17246
17247
17248 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17249 PyObject *resultobj;
17250 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17251 wxString *arg2 = 0 ;
17252 bool result;
17253 bool temp2 = false ;
17254 PyObject * obj0 = 0 ;
17255 PyObject * obj1 = 0 ;
17256 char *kwnames[] = {
17257 (char *) "self",(char *) "name", NULL
17258 };
17259
17260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17262 if (SWIG_arg_fail(1)) SWIG_fail;
17263 {
17264 arg2 = wxString_in_helper(obj1);
17265 if (arg2 == NULL) SWIG_fail;
17266 temp2 = true;
17267 }
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17271
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 {
17276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17277 }
17278 {
17279 if (temp2)
17280 delete arg2;
17281 }
17282 return resultobj;
17283 fail:
17284 {
17285 if (temp2)
17286 delete arg2;
17287 }
17288 return NULL;
17289 }
17290
17291
17292 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj;
17294 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17295 wxString *arg2 = 0 ;
17296 wxConfigBase::EntryType result;
17297 bool temp2 = false ;
17298 PyObject * obj0 = 0 ;
17299 PyObject * obj1 = 0 ;
17300 char *kwnames[] = {
17301 (char *) "self",(char *) "name", NULL
17302 };
17303
17304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17306 if (SWIG_arg_fail(1)) SWIG_fail;
17307 {
17308 arg2 = wxString_in_helper(obj1);
17309 if (arg2 == NULL) SWIG_fail;
17310 temp2 = true;
17311 }
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17315
17316 wxPyEndAllowThreads(__tstate);
17317 if (PyErr_Occurred()) SWIG_fail;
17318 }
17319 resultobj = SWIG_From_int((result));
17320 {
17321 if (temp2)
17322 delete arg2;
17323 }
17324 return resultobj;
17325 fail:
17326 {
17327 if (temp2)
17328 delete arg2;
17329 }
17330 return NULL;
17331 }
17332
17333
17334 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17335 PyObject *resultobj;
17336 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17337 wxString *arg2 = 0 ;
17338 wxString const &arg3_defvalue = wxPyEmptyString ;
17339 wxString *arg3 = (wxString *) &arg3_defvalue ;
17340 wxString result;
17341 bool temp2 = false ;
17342 bool temp3 = false ;
17343 PyObject * obj0 = 0 ;
17344 PyObject * obj1 = 0 ;
17345 PyObject * obj2 = 0 ;
17346 char *kwnames[] = {
17347 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17348 };
17349
17350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17352 if (SWIG_arg_fail(1)) SWIG_fail;
17353 {
17354 arg2 = wxString_in_helper(obj1);
17355 if (arg2 == NULL) SWIG_fail;
17356 temp2 = true;
17357 }
17358 if (obj2) {
17359 {
17360 arg3 = wxString_in_helper(obj2);
17361 if (arg3 == NULL) SWIG_fail;
17362 temp3 = true;
17363 }
17364 }
17365 {
17366 PyThreadState* __tstate = wxPyBeginAllowThreads();
17367 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17368
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 {
17373 #if wxUSE_UNICODE
17374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17375 #else
17376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17377 #endif
17378 }
17379 {
17380 if (temp2)
17381 delete arg2;
17382 }
17383 {
17384 if (temp3)
17385 delete arg3;
17386 }
17387 return resultobj;
17388 fail:
17389 {
17390 if (temp2)
17391 delete arg2;
17392 }
17393 {
17394 if (temp3)
17395 delete arg3;
17396 }
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17404 wxString *arg2 = 0 ;
17405 long arg3 = (long) 0 ;
17406 long result;
17407 bool temp2 = false ;
17408 PyObject * obj0 = 0 ;
17409 PyObject * obj1 = 0 ;
17410 PyObject * obj2 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 {
17419 arg2 = wxString_in_helper(obj1);
17420 if (arg2 == NULL) SWIG_fail;
17421 temp2 = true;
17422 }
17423 if (obj2) {
17424 {
17425 arg3 = (long)(SWIG_As_long(obj2));
17426 if (SWIG_arg_fail(3)) SWIG_fail;
17427 }
17428 }
17429 {
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17432
17433 wxPyEndAllowThreads(__tstate);
17434 if (PyErr_Occurred()) SWIG_fail;
17435 }
17436 {
17437 resultobj = SWIG_From_long((long)(result));
17438 }
17439 {
17440 if (temp2)
17441 delete arg2;
17442 }
17443 return resultobj;
17444 fail:
17445 {
17446 if (temp2)
17447 delete arg2;
17448 }
17449 return NULL;
17450 }
17451
17452
17453 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17454 PyObject *resultobj;
17455 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17456 wxString *arg2 = 0 ;
17457 double arg3 = (double) 0.0 ;
17458 double result;
17459 bool temp2 = false ;
17460 PyObject * obj0 = 0 ;
17461 PyObject * obj1 = 0 ;
17462 PyObject * obj2 = 0 ;
17463 char *kwnames[] = {
17464 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17465 };
17466
17467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17469 if (SWIG_arg_fail(1)) SWIG_fail;
17470 {
17471 arg2 = wxString_in_helper(obj1);
17472 if (arg2 == NULL) SWIG_fail;
17473 temp2 = true;
17474 }
17475 if (obj2) {
17476 {
17477 arg3 = (double)(SWIG_As_double(obj2));
17478 if (SWIG_arg_fail(3)) SWIG_fail;
17479 }
17480 }
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17484
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 {
17489 resultobj = SWIG_From_double((double)(result));
17490 }
17491 {
17492 if (temp2)
17493 delete arg2;
17494 }
17495 return resultobj;
17496 fail:
17497 {
17498 if (temp2)
17499 delete arg2;
17500 }
17501 return NULL;
17502 }
17503
17504
17505 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17506 PyObject *resultobj;
17507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17508 wxString *arg2 = 0 ;
17509 bool arg3 = (bool) false ;
17510 bool result;
17511 bool temp2 = false ;
17512 PyObject * obj0 = 0 ;
17513 PyObject * obj1 = 0 ;
17514 PyObject * obj2 = 0 ;
17515 char *kwnames[] = {
17516 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17517 };
17518
17519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17521 if (SWIG_arg_fail(1)) SWIG_fail;
17522 {
17523 arg2 = wxString_in_helper(obj1);
17524 if (arg2 == NULL) SWIG_fail;
17525 temp2 = true;
17526 }
17527 if (obj2) {
17528 {
17529 arg3 = (bool)(SWIG_As_bool(obj2));
17530 if (SWIG_arg_fail(3)) SWIG_fail;
17531 }
17532 }
17533 {
17534 PyThreadState* __tstate = wxPyBeginAllowThreads();
17535 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17536
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17542 }
17543 {
17544 if (temp2)
17545 delete arg2;
17546 }
17547 return resultobj;
17548 fail:
17549 {
17550 if (temp2)
17551 delete arg2;
17552 }
17553 return NULL;
17554 }
17555
17556
17557 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17558 PyObject *resultobj;
17559 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17560 wxString *arg2 = 0 ;
17561 wxString *arg3 = 0 ;
17562 bool result;
17563 bool temp2 = false ;
17564 bool temp3 = false ;
17565 PyObject * obj0 = 0 ;
17566 PyObject * obj1 = 0 ;
17567 PyObject * obj2 = 0 ;
17568 char *kwnames[] = {
17569 (char *) "self",(char *) "key",(char *) "value", NULL
17570 };
17571
17572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17574 if (SWIG_arg_fail(1)) SWIG_fail;
17575 {
17576 arg2 = wxString_in_helper(obj1);
17577 if (arg2 == NULL) SWIG_fail;
17578 temp2 = true;
17579 }
17580 {
17581 arg3 = wxString_in_helper(obj2);
17582 if (arg3 == NULL) SWIG_fail;
17583 temp3 = true;
17584 }
17585 {
17586 PyThreadState* __tstate = wxPyBeginAllowThreads();
17587 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17588
17589 wxPyEndAllowThreads(__tstate);
17590 if (PyErr_Occurred()) SWIG_fail;
17591 }
17592 {
17593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17594 }
17595 {
17596 if (temp2)
17597 delete arg2;
17598 }
17599 {
17600 if (temp3)
17601 delete arg3;
17602 }
17603 return resultobj;
17604 fail:
17605 {
17606 if (temp2)
17607 delete arg2;
17608 }
17609 {
17610 if (temp3)
17611 delete arg3;
17612 }
17613 return NULL;
17614 }
17615
17616
17617 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17618 PyObject *resultobj;
17619 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17620 wxString *arg2 = 0 ;
17621 long arg3 ;
17622 bool result;
17623 bool temp2 = false ;
17624 PyObject * obj0 = 0 ;
17625 PyObject * obj1 = 0 ;
17626 PyObject * obj2 = 0 ;
17627 char *kwnames[] = {
17628 (char *) "self",(char *) "key",(char *) "value", NULL
17629 };
17630
17631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17633 if (SWIG_arg_fail(1)) SWIG_fail;
17634 {
17635 arg2 = wxString_in_helper(obj1);
17636 if (arg2 == NULL) SWIG_fail;
17637 temp2 = true;
17638 }
17639 {
17640 arg3 = (long)(SWIG_As_long(obj2));
17641 if (SWIG_arg_fail(3)) SWIG_fail;
17642 }
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17646
17647 wxPyEndAllowThreads(__tstate);
17648 if (PyErr_Occurred()) SWIG_fail;
17649 }
17650 {
17651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17652 }
17653 {
17654 if (temp2)
17655 delete arg2;
17656 }
17657 return resultobj;
17658 fail:
17659 {
17660 if (temp2)
17661 delete arg2;
17662 }
17663 return NULL;
17664 }
17665
17666
17667 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj;
17669 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17670 wxString *arg2 = 0 ;
17671 double arg3 ;
17672 bool result;
17673 bool temp2 = false ;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 PyObject * obj2 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "key",(char *) "value", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 arg2 = wxString_in_helper(obj1);
17686 if (arg2 == NULL) SWIG_fail;
17687 temp2 = true;
17688 }
17689 {
17690 arg3 = (double)(SWIG_As_double(obj2));
17691 if (SWIG_arg_fail(3)) SWIG_fail;
17692 }
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 {
17701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17702 }
17703 {
17704 if (temp2)
17705 delete arg2;
17706 }
17707 return resultobj;
17708 fail:
17709 {
17710 if (temp2)
17711 delete arg2;
17712 }
17713 return NULL;
17714 }
17715
17716
17717 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17718 PyObject *resultobj;
17719 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17720 wxString *arg2 = 0 ;
17721 bool arg3 ;
17722 bool result;
17723 bool temp2 = false ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 PyObject * obj2 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self",(char *) "key",(char *) "value", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 arg2 = wxString_in_helper(obj1);
17736 if (arg2 == NULL) SWIG_fail;
17737 temp2 = true;
17738 }
17739 {
17740 arg3 = (bool)(SWIG_As_bool(obj2));
17741 if (SWIG_arg_fail(3)) SWIG_fail;
17742 }
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17746
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 {
17754 if (temp2)
17755 delete arg2;
17756 }
17757 return resultobj;
17758 fail:
17759 {
17760 if (temp2)
17761 delete arg2;
17762 }
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj;
17769 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17770 bool arg2 = (bool) false ;
17771 bool result;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self",(char *) "currentOnly", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 if (obj1) {
17782 {
17783 arg2 = (bool)(SWIG_As_bool(obj1));
17784 if (SWIG_arg_fail(2)) SWIG_fail;
17785 }
17786 }
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 result = (bool)(arg1)->Flush(arg2);
17790
17791 wxPyEndAllowThreads(__tstate);
17792 if (PyErr_Occurred()) SWIG_fail;
17793 }
17794 {
17795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17796 }
17797 return resultobj;
17798 fail:
17799 return NULL;
17800 }
17801
17802
17803 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17804 PyObject *resultobj;
17805 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17806 wxString *arg2 = 0 ;
17807 wxString *arg3 = 0 ;
17808 bool result;
17809 bool temp2 = false ;
17810 bool temp3 = false ;
17811 PyObject * obj0 = 0 ;
17812 PyObject * obj1 = 0 ;
17813 PyObject * obj2 = 0 ;
17814 char *kwnames[] = {
17815 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17816 };
17817
17818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17820 if (SWIG_arg_fail(1)) SWIG_fail;
17821 {
17822 arg2 = wxString_in_helper(obj1);
17823 if (arg2 == NULL) SWIG_fail;
17824 temp2 = true;
17825 }
17826 {
17827 arg3 = wxString_in_helper(obj2);
17828 if (arg3 == NULL) SWIG_fail;
17829 temp3 = true;
17830 }
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17834
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 {
17839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17840 }
17841 {
17842 if (temp2)
17843 delete arg2;
17844 }
17845 {
17846 if (temp3)
17847 delete arg3;
17848 }
17849 return resultobj;
17850 fail:
17851 {
17852 if (temp2)
17853 delete arg2;
17854 }
17855 {
17856 if (temp3)
17857 delete arg3;
17858 }
17859 return NULL;
17860 }
17861
17862
17863 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17864 PyObject *resultobj;
17865 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17866 wxString *arg2 = 0 ;
17867 wxString *arg3 = 0 ;
17868 bool result;
17869 bool temp2 = false ;
17870 bool temp3 = false ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 PyObject * obj2 = 0 ;
17874 char *kwnames[] = {
17875 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17876 };
17877
17878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17880 if (SWIG_arg_fail(1)) SWIG_fail;
17881 {
17882 arg2 = wxString_in_helper(obj1);
17883 if (arg2 == NULL) SWIG_fail;
17884 temp2 = true;
17885 }
17886 {
17887 arg3 = wxString_in_helper(obj2);
17888 if (arg3 == NULL) SWIG_fail;
17889 temp3 = true;
17890 }
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17894
17895 wxPyEndAllowThreads(__tstate);
17896 if (PyErr_Occurred()) SWIG_fail;
17897 }
17898 {
17899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17900 }
17901 {
17902 if (temp2)
17903 delete arg2;
17904 }
17905 {
17906 if (temp3)
17907 delete arg3;
17908 }
17909 return resultobj;
17910 fail:
17911 {
17912 if (temp2)
17913 delete arg2;
17914 }
17915 {
17916 if (temp3)
17917 delete arg3;
17918 }
17919 return NULL;
17920 }
17921
17922
17923 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17924 PyObject *resultobj;
17925 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17926 wxString *arg2 = 0 ;
17927 bool arg3 = (bool) true ;
17928 bool result;
17929 bool temp2 = false ;
17930 PyObject * obj0 = 0 ;
17931 PyObject * obj1 = 0 ;
17932 PyObject * obj2 = 0 ;
17933 char *kwnames[] = {
17934 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17935 };
17936
17937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17939 if (SWIG_arg_fail(1)) SWIG_fail;
17940 {
17941 arg2 = wxString_in_helper(obj1);
17942 if (arg2 == NULL) SWIG_fail;
17943 temp2 = true;
17944 }
17945 if (obj2) {
17946 {
17947 arg3 = (bool)(SWIG_As_bool(obj2));
17948 if (SWIG_arg_fail(3)) SWIG_fail;
17949 }
17950 }
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 {
17959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17960 }
17961 {
17962 if (temp2)
17963 delete arg2;
17964 }
17965 return resultobj;
17966 fail:
17967 {
17968 if (temp2)
17969 delete arg2;
17970 }
17971 return NULL;
17972 }
17973
17974
17975 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17976 PyObject *resultobj;
17977 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17978 wxString *arg2 = 0 ;
17979 bool result;
17980 bool temp2 = false ;
17981 PyObject * obj0 = 0 ;
17982 PyObject * obj1 = 0 ;
17983 char *kwnames[] = {
17984 (char *) "self",(char *) "key", NULL
17985 };
17986
17987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17989 if (SWIG_arg_fail(1)) SWIG_fail;
17990 {
17991 arg2 = wxString_in_helper(obj1);
17992 if (arg2 == NULL) SWIG_fail;
17993 temp2 = true;
17994 }
17995 {
17996 PyThreadState* __tstate = wxPyBeginAllowThreads();
17997 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17998
17999 wxPyEndAllowThreads(__tstate);
18000 if (PyErr_Occurred()) SWIG_fail;
18001 }
18002 {
18003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18004 }
18005 {
18006 if (temp2)
18007 delete arg2;
18008 }
18009 return resultobj;
18010 fail:
18011 {
18012 if (temp2)
18013 delete arg2;
18014 }
18015 return NULL;
18016 }
18017
18018
18019 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18020 PyObject *resultobj;
18021 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18022 bool result;
18023 PyObject * obj0 = 0 ;
18024 char *kwnames[] = {
18025 (char *) "self", NULL
18026 };
18027
18028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(1)) SWIG_fail;
18031 {
18032 PyThreadState* __tstate = wxPyBeginAllowThreads();
18033 result = (bool)(arg1)->DeleteAll();
18034
18035 wxPyEndAllowThreads(__tstate);
18036 if (PyErr_Occurred()) SWIG_fail;
18037 }
18038 {
18039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18040 }
18041 return resultobj;
18042 fail:
18043 return NULL;
18044 }
18045
18046
18047 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18048 PyObject *resultobj;
18049 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18050 bool arg2 = (bool) true ;
18051 PyObject * obj0 = 0 ;
18052 PyObject * obj1 = 0 ;
18053 char *kwnames[] = {
18054 (char *) "self",(char *) "doIt", NULL
18055 };
18056
18057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18059 if (SWIG_arg_fail(1)) SWIG_fail;
18060 if (obj1) {
18061 {
18062 arg2 = (bool)(SWIG_As_bool(obj1));
18063 if (SWIG_arg_fail(2)) SWIG_fail;
18064 }
18065 }
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 (arg1)->SetExpandEnvVars(arg2);
18069
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 Py_INCREF(Py_None); resultobj = Py_None;
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj;
18082 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18083 bool result;
18084 PyObject * obj0 = 0 ;
18085 char *kwnames[] = {
18086 (char *) "self", NULL
18087 };
18088
18089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18091 if (SWIG_arg_fail(1)) SWIG_fail;
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18095
18096 wxPyEndAllowThreads(__tstate);
18097 if (PyErr_Occurred()) SWIG_fail;
18098 }
18099 {
18100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18101 }
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj;
18110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18111 bool arg2 = (bool) true ;
18112 PyObject * obj0 = 0 ;
18113 PyObject * obj1 = 0 ;
18114 char *kwnames[] = {
18115 (char *) "self",(char *) "doIt", NULL
18116 };
18117
18118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18120 if (SWIG_arg_fail(1)) SWIG_fail;
18121 if (obj1) {
18122 {
18123 arg2 = (bool)(SWIG_As_bool(obj1));
18124 if (SWIG_arg_fail(2)) SWIG_fail;
18125 }
18126 }
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 (arg1)->SetRecordDefaults(arg2);
18130
18131 wxPyEndAllowThreads(__tstate);
18132 if (PyErr_Occurred()) SWIG_fail;
18133 }
18134 Py_INCREF(Py_None); resultobj = Py_None;
18135 return resultobj;
18136 fail:
18137 return NULL;
18138 }
18139
18140
18141 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18142 PyObject *resultobj;
18143 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18144 bool result;
18145 PyObject * obj0 = 0 ;
18146 char *kwnames[] = {
18147 (char *) "self", NULL
18148 };
18149
18150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18152 if (SWIG_arg_fail(1)) SWIG_fail;
18153 {
18154 PyThreadState* __tstate = wxPyBeginAllowThreads();
18155 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18156
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 {
18161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18162 }
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18170 PyObject *resultobj;
18171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18172 wxString *arg2 = 0 ;
18173 wxString result;
18174 bool temp2 = false ;
18175 PyObject * obj0 = 0 ;
18176 PyObject * obj1 = 0 ;
18177 char *kwnames[] = {
18178 (char *) "self",(char *) "str", NULL
18179 };
18180
18181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18183 if (SWIG_arg_fail(1)) SWIG_fail;
18184 {
18185 arg2 = wxString_in_helper(obj1);
18186 if (arg2 == NULL) SWIG_fail;
18187 temp2 = true;
18188 }
18189 {
18190 PyThreadState* __tstate = wxPyBeginAllowThreads();
18191 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18192
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 {
18197 #if wxUSE_UNICODE
18198 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18199 #else
18200 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18201 #endif
18202 }
18203 {
18204 if (temp2)
18205 delete arg2;
18206 }
18207 return resultobj;
18208 fail:
18209 {
18210 if (temp2)
18211 delete arg2;
18212 }
18213 return NULL;
18214 }
18215
18216
18217 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18218 PyObject *resultobj;
18219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18220 wxString result;
18221 PyObject * obj0 = 0 ;
18222 char *kwnames[] = {
18223 (char *) "self", NULL
18224 };
18225
18226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18228 if (SWIG_arg_fail(1)) SWIG_fail;
18229 {
18230 PyThreadState* __tstate = wxPyBeginAllowThreads();
18231 result = ((wxConfigBase const *)arg1)->GetAppName();
18232
18233 wxPyEndAllowThreads(__tstate);
18234 if (PyErr_Occurred()) SWIG_fail;
18235 }
18236 {
18237 #if wxUSE_UNICODE
18238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18239 #else
18240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18241 #endif
18242 }
18243 return resultobj;
18244 fail:
18245 return NULL;
18246 }
18247
18248
18249 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18250 PyObject *resultobj;
18251 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18252 wxString result;
18253 PyObject * obj0 = 0 ;
18254 char *kwnames[] = {
18255 (char *) "self", NULL
18256 };
18257
18258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18260 if (SWIG_arg_fail(1)) SWIG_fail;
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = ((wxConfigBase const *)arg1)->GetVendorName();
18264
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 {
18269 #if wxUSE_UNICODE
18270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18271 #else
18272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18273 #endif
18274 }
18275 return resultobj;
18276 fail:
18277 return NULL;
18278 }
18279
18280
18281 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18282 PyObject *resultobj;
18283 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18284 wxString *arg2 = 0 ;
18285 bool temp2 = false ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 char *kwnames[] = {
18289 (char *) "self",(char *) "appName", NULL
18290 };
18291
18292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18294 if (SWIG_arg_fail(1)) SWIG_fail;
18295 {
18296 arg2 = wxString_in_helper(obj1);
18297 if (arg2 == NULL) SWIG_fail;
18298 temp2 = true;
18299 }
18300 {
18301 PyThreadState* __tstate = wxPyBeginAllowThreads();
18302 (arg1)->SetAppName((wxString const &)*arg2);
18303
18304 wxPyEndAllowThreads(__tstate);
18305 if (PyErr_Occurred()) SWIG_fail;
18306 }
18307 Py_INCREF(Py_None); resultobj = Py_None;
18308 {
18309 if (temp2)
18310 delete arg2;
18311 }
18312 return resultobj;
18313 fail:
18314 {
18315 if (temp2)
18316 delete arg2;
18317 }
18318 return NULL;
18319 }
18320
18321
18322 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18323 PyObject *resultobj;
18324 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18325 wxString *arg2 = 0 ;
18326 bool temp2 = false ;
18327 PyObject * obj0 = 0 ;
18328 PyObject * obj1 = 0 ;
18329 char *kwnames[] = {
18330 (char *) "self",(char *) "vendorName", NULL
18331 };
18332
18333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18335 if (SWIG_arg_fail(1)) SWIG_fail;
18336 {
18337 arg2 = wxString_in_helper(obj1);
18338 if (arg2 == NULL) SWIG_fail;
18339 temp2 = true;
18340 }
18341 {
18342 PyThreadState* __tstate = wxPyBeginAllowThreads();
18343 (arg1)->SetVendorName((wxString const &)*arg2);
18344
18345 wxPyEndAllowThreads(__tstate);
18346 if (PyErr_Occurred()) SWIG_fail;
18347 }
18348 Py_INCREF(Py_None); resultobj = Py_None;
18349 {
18350 if (temp2)
18351 delete arg2;
18352 }
18353 return resultobj;
18354 fail:
18355 {
18356 if (temp2)
18357 delete arg2;
18358 }
18359 return NULL;
18360 }
18361
18362
18363 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj;
18365 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18366 long arg2 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char *kwnames[] = {
18370 (char *) "self",(char *) "style", NULL
18371 };
18372
18373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18375 if (SWIG_arg_fail(1)) SWIG_fail;
18376 {
18377 arg2 = (long)(SWIG_As_long(obj1));
18378 if (SWIG_arg_fail(2)) SWIG_fail;
18379 }
18380 {
18381 PyThreadState* __tstate = wxPyBeginAllowThreads();
18382 (arg1)->SetStyle(arg2);
18383
18384 wxPyEndAllowThreads(__tstate);
18385 if (PyErr_Occurred()) SWIG_fail;
18386 }
18387 Py_INCREF(Py_None); resultobj = Py_None;
18388 return resultobj;
18389 fail:
18390 return NULL;
18391 }
18392
18393
18394 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18395 PyObject *resultobj;
18396 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18397 long result;
18398 PyObject * obj0 = 0 ;
18399 char *kwnames[] = {
18400 (char *) "self", NULL
18401 };
18402
18403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18405 if (SWIG_arg_fail(1)) SWIG_fail;
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18409
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 {
18414 resultobj = SWIG_From_long((long)(result));
18415 }
18416 return resultobj;
18417 fail:
18418 return NULL;
18419 }
18420
18421
18422 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18423 PyObject *obj;
18424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18425 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18426 Py_INCREF(obj);
18427 return Py_BuildValue((char *)"");
18428 }
18429 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj;
18431 wxString const &arg1_defvalue = wxPyEmptyString ;
18432 wxString *arg1 = (wxString *) &arg1_defvalue ;
18433 wxString const &arg2_defvalue = wxPyEmptyString ;
18434 wxString *arg2 = (wxString *) &arg2_defvalue ;
18435 wxString const &arg3_defvalue = wxPyEmptyString ;
18436 wxString *arg3 = (wxString *) &arg3_defvalue ;
18437 wxString const &arg4_defvalue = wxPyEmptyString ;
18438 wxString *arg4 = (wxString *) &arg4_defvalue ;
18439 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18440 wxConfig *result;
18441 bool temp1 = false ;
18442 bool temp2 = false ;
18443 bool temp3 = false ;
18444 bool temp4 = false ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 PyObject * obj2 = 0 ;
18448 PyObject * obj3 = 0 ;
18449 PyObject * obj4 = 0 ;
18450 char *kwnames[] = {
18451 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18452 };
18453
18454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18455 if (obj0) {
18456 {
18457 arg1 = wxString_in_helper(obj0);
18458 if (arg1 == NULL) SWIG_fail;
18459 temp1 = true;
18460 }
18461 }
18462 if (obj1) {
18463 {
18464 arg2 = wxString_in_helper(obj1);
18465 if (arg2 == NULL) SWIG_fail;
18466 temp2 = true;
18467 }
18468 }
18469 if (obj2) {
18470 {
18471 arg3 = wxString_in_helper(obj2);
18472 if (arg3 == NULL) SWIG_fail;
18473 temp3 = true;
18474 }
18475 }
18476 if (obj3) {
18477 {
18478 arg4 = wxString_in_helper(obj3);
18479 if (arg4 == NULL) SWIG_fail;
18480 temp4 = true;
18481 }
18482 }
18483 if (obj4) {
18484 {
18485 arg5 = (long)(SWIG_As_long(obj4));
18486 if (SWIG_arg_fail(5)) SWIG_fail;
18487 }
18488 }
18489 {
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18492
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18497 {
18498 if (temp1)
18499 delete arg1;
18500 }
18501 {
18502 if (temp2)
18503 delete arg2;
18504 }
18505 {
18506 if (temp3)
18507 delete arg3;
18508 }
18509 {
18510 if (temp4)
18511 delete arg4;
18512 }
18513 return resultobj;
18514 fail:
18515 {
18516 if (temp1)
18517 delete arg1;
18518 }
18519 {
18520 if (temp2)
18521 delete arg2;
18522 }
18523 {
18524 if (temp3)
18525 delete arg3;
18526 }
18527 {
18528 if (temp4)
18529 delete arg4;
18530 }
18531 return NULL;
18532 }
18533
18534
18535 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18536 PyObject *resultobj;
18537 wxConfig *arg1 = (wxConfig *) 0 ;
18538 PyObject * obj0 = 0 ;
18539 char *kwnames[] = {
18540 (char *) "self", NULL
18541 };
18542
18543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18545 if (SWIG_arg_fail(1)) SWIG_fail;
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 delete arg1;
18549
18550 wxPyEndAllowThreads(__tstate);
18551 if (PyErr_Occurred()) SWIG_fail;
18552 }
18553 Py_INCREF(Py_None); resultobj = Py_None;
18554 return resultobj;
18555 fail:
18556 return NULL;
18557 }
18558
18559
18560 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18561 PyObject *obj;
18562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18563 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18564 Py_INCREF(obj);
18565 return Py_BuildValue((char *)"");
18566 }
18567 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18568 PyObject *resultobj;
18569 wxString const &arg1_defvalue = wxPyEmptyString ;
18570 wxString *arg1 = (wxString *) &arg1_defvalue ;
18571 wxString const &arg2_defvalue = wxPyEmptyString ;
18572 wxString *arg2 = (wxString *) &arg2_defvalue ;
18573 wxString const &arg3_defvalue = wxPyEmptyString ;
18574 wxString *arg3 = (wxString *) &arg3_defvalue ;
18575 wxString const &arg4_defvalue = wxPyEmptyString ;
18576 wxString *arg4 = (wxString *) &arg4_defvalue ;
18577 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18578 wxFileConfig *result;
18579 bool temp1 = false ;
18580 bool temp2 = false ;
18581 bool temp3 = false ;
18582 bool temp4 = false ;
18583 PyObject * obj0 = 0 ;
18584 PyObject * obj1 = 0 ;
18585 PyObject * obj2 = 0 ;
18586 PyObject * obj3 = 0 ;
18587 PyObject * obj4 = 0 ;
18588 char *kwnames[] = {
18589 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18590 };
18591
18592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18593 if (obj0) {
18594 {
18595 arg1 = wxString_in_helper(obj0);
18596 if (arg1 == NULL) SWIG_fail;
18597 temp1 = true;
18598 }
18599 }
18600 if (obj1) {
18601 {
18602 arg2 = wxString_in_helper(obj1);
18603 if (arg2 == NULL) SWIG_fail;
18604 temp2 = true;
18605 }
18606 }
18607 if (obj2) {
18608 {
18609 arg3 = wxString_in_helper(obj2);
18610 if (arg3 == NULL) SWIG_fail;
18611 temp3 = true;
18612 }
18613 }
18614 if (obj3) {
18615 {
18616 arg4 = wxString_in_helper(obj3);
18617 if (arg4 == NULL) SWIG_fail;
18618 temp4 = true;
18619 }
18620 }
18621 if (obj4) {
18622 {
18623 arg5 = (long)(SWIG_As_long(obj4));
18624 if (SWIG_arg_fail(5)) SWIG_fail;
18625 }
18626 }
18627 {
18628 PyThreadState* __tstate = wxPyBeginAllowThreads();
18629 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18630
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18635 {
18636 if (temp1)
18637 delete arg1;
18638 }
18639 {
18640 if (temp2)
18641 delete arg2;
18642 }
18643 {
18644 if (temp3)
18645 delete arg3;
18646 }
18647 {
18648 if (temp4)
18649 delete arg4;
18650 }
18651 return resultobj;
18652 fail:
18653 {
18654 if (temp1)
18655 delete arg1;
18656 }
18657 {
18658 if (temp2)
18659 delete arg2;
18660 }
18661 {
18662 if (temp3)
18663 delete arg3;
18664 }
18665 {
18666 if (temp4)
18667 delete arg4;
18668 }
18669 return NULL;
18670 }
18671
18672
18673 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj;
18675 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18676 PyObject * obj0 = 0 ;
18677 char *kwnames[] = {
18678 (char *) "self", NULL
18679 };
18680
18681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18683 if (SWIG_arg_fail(1)) SWIG_fail;
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 delete arg1;
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 Py_INCREF(Py_None); resultobj = Py_None;
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18699 PyObject *obj;
18700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18701 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18702 Py_INCREF(obj);
18703 return Py_BuildValue((char *)"");
18704 }
18705 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18706 PyObject *resultobj;
18707 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18708 wxString *arg2 = 0 ;
18709 wxConfigPathChanger *result;
18710 bool temp2 = false ;
18711 PyObject * obj0 = 0 ;
18712 PyObject * obj1 = 0 ;
18713 char *kwnames[] = {
18714 (char *) "config",(char *) "entry", NULL
18715 };
18716
18717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18719 if (SWIG_arg_fail(1)) SWIG_fail;
18720 {
18721 arg2 = wxString_in_helper(obj1);
18722 if (arg2 == NULL) SWIG_fail;
18723 temp2 = true;
18724 }
18725 {
18726 PyThreadState* __tstate = wxPyBeginAllowThreads();
18727 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18728
18729 wxPyEndAllowThreads(__tstate);
18730 if (PyErr_Occurred()) SWIG_fail;
18731 }
18732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18733 {
18734 if (temp2)
18735 delete arg2;
18736 }
18737 return resultobj;
18738 fail:
18739 {
18740 if (temp2)
18741 delete arg2;
18742 }
18743 return NULL;
18744 }
18745
18746
18747 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18748 PyObject *resultobj;
18749 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18750 PyObject * obj0 = 0 ;
18751 char *kwnames[] = {
18752 (char *) "self", NULL
18753 };
18754
18755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18757 if (SWIG_arg_fail(1)) SWIG_fail;
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 delete arg1;
18761
18762 wxPyEndAllowThreads(__tstate);
18763 if (PyErr_Occurred()) SWIG_fail;
18764 }
18765 Py_INCREF(Py_None); resultobj = Py_None;
18766 return resultobj;
18767 fail:
18768 return NULL;
18769 }
18770
18771
18772 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18773 PyObject *resultobj;
18774 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18775 wxString *result;
18776 PyObject * obj0 = 0 ;
18777 char *kwnames[] = {
18778 (char *) "self", NULL
18779 };
18780
18781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18783 if (SWIG_arg_fail(1)) SWIG_fail;
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 {
18787 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18788 result = (wxString *) &_result_ref;
18789 }
18790
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 {
18795 #if wxUSE_UNICODE
18796 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18797 #else
18798 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18799 #endif
18800 }
18801 return resultobj;
18802 fail:
18803 return NULL;
18804 }
18805
18806
18807 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18808 PyObject *obj;
18809 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18810 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18811 Py_INCREF(obj);
18812 return Py_BuildValue((char *)"");
18813 }
18814 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj;
18816 wxString *arg1 = 0 ;
18817 wxString result;
18818 bool temp1 = false ;
18819 PyObject * obj0 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "sz", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18825 {
18826 arg1 = wxString_in_helper(obj0);
18827 if (arg1 == NULL) SWIG_fail;
18828 temp1 = true;
18829 }
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = wxExpandEnvVars((wxString const &)*arg1);
18833
18834 wxPyEndAllowThreads(__tstate);
18835 if (PyErr_Occurred()) SWIG_fail;
18836 }
18837 {
18838 #if wxUSE_UNICODE
18839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18840 #else
18841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18842 #endif
18843 }
18844 {
18845 if (temp1)
18846 delete arg1;
18847 }
18848 return resultobj;
18849 fail:
18850 {
18851 if (temp1)
18852 delete arg1;
18853 }
18854 return NULL;
18855 }
18856
18857
18858 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18859 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18860 return 1;
18861 }
18862
18863
18864 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18865 PyObject *pyobj;
18866
18867 {
18868 #if wxUSE_UNICODE
18869 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18870 #else
18871 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18872 #endif
18873 }
18874 return pyobj;
18875 }
18876
18877
18878 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18879 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18880 return 1;
18881 }
18882
18883
18884 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18885 PyObject *pyobj;
18886
18887 {
18888 #if wxUSE_UNICODE
18889 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18890 #else
18891 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18892 #endif
18893 }
18894 return pyobj;
18895 }
18896
18897
18898 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj;
18900 wxDateTime::Country arg1 ;
18901 PyObject * obj0 = 0 ;
18902 char *kwnames[] = {
18903 (char *) "country", NULL
18904 };
18905
18906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18907 {
18908 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18909 if (SWIG_arg_fail(1)) SWIG_fail;
18910 }
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18914
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 Py_INCREF(Py_None); resultobj = Py_None;
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj;
18927 wxDateTime::Country result;
18928 char *kwnames[] = {
18929 NULL
18930 };
18931
18932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18933 {
18934 PyThreadState* __tstate = wxPyBeginAllowThreads();
18935 result = (wxDateTime::Country)wxDateTime::GetCountry();
18936
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 resultobj = SWIG_From_int((result));
18941 return resultobj;
18942 fail:
18943 return NULL;
18944 }
18945
18946
18947 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18948 PyObject *resultobj;
18949 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18950 bool result;
18951 PyObject * obj0 = 0 ;
18952 char *kwnames[] = {
18953 (char *) "country", NULL
18954 };
18955
18956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18957 if (obj0) {
18958 {
18959 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 }
18962 }
18963 {
18964 PyThreadState* __tstate = wxPyBeginAllowThreads();
18965 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18966
18967 wxPyEndAllowThreads(__tstate);
18968 if (PyErr_Occurred()) SWIG_fail;
18969 }
18970 {
18971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18972 }
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18980 PyObject *resultobj;
18981 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18982 int result;
18983 PyObject * obj0 = 0 ;
18984 char *kwnames[] = {
18985 (char *) "cal", NULL
18986 };
18987
18988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18989 if (obj0) {
18990 {
18991 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18992 if (SWIG_arg_fail(1)) SWIG_fail;
18993 }
18994 }
18995 {
18996 PyThreadState* __tstate = wxPyBeginAllowThreads();
18997 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18998
18999 wxPyEndAllowThreads(__tstate);
19000 if (PyErr_Occurred()) SWIG_fail;
19001 }
19002 {
19003 resultobj = SWIG_From_int((int)(result));
19004 }
19005 return resultobj;
19006 fail:
19007 return NULL;
19008 }
19009
19010
19011 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19012 PyObject *resultobj;
19013 int arg1 ;
19014 int result;
19015 PyObject * obj0 = 0 ;
19016 char *kwnames[] = {
19017 (char *) "year", NULL
19018 };
19019
19020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19021 {
19022 arg1 = (int)(SWIG_As_int(obj0));
19023 if (SWIG_arg_fail(1)) SWIG_fail;
19024 }
19025 {
19026 PyThreadState* __tstate = wxPyBeginAllowThreads();
19027 result = (int)wxDateTime::ConvertYearToBC(arg1);
19028
19029 wxPyEndAllowThreads(__tstate);
19030 if (PyErr_Occurred()) SWIG_fail;
19031 }
19032 {
19033 resultobj = SWIG_From_int((int)(result));
19034 }
19035 return resultobj;
19036 fail:
19037 return NULL;
19038 }
19039
19040
19041 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19042 PyObject *resultobj;
19043 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19044 wxDateTime::Month result;
19045 PyObject * obj0 = 0 ;
19046 char *kwnames[] = {
19047 (char *) "cal", NULL
19048 };
19049
19050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19051 if (obj0) {
19052 {
19053 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19054 if (SWIG_arg_fail(1)) SWIG_fail;
19055 }
19056 }
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19060
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_From_int((result));
19065 return resultobj;
19066 fail:
19067 return NULL;
19068 }
19069
19070
19071 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19072 PyObject *resultobj;
19073 int arg1 = (int) wxDateTime::Inv_Year ;
19074 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19075 bool result;
19076 PyObject * obj0 = 0 ;
19077 PyObject * obj1 = 0 ;
19078 char *kwnames[] = {
19079 (char *) "year",(char *) "cal", NULL
19080 };
19081
19082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19083 if (obj0) {
19084 {
19085 arg1 = (int)(SWIG_As_int(obj0));
19086 if (SWIG_arg_fail(1)) SWIG_fail;
19087 }
19088 }
19089 if (obj1) {
19090 {
19091 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19092 if (SWIG_arg_fail(2)) SWIG_fail;
19093 }
19094 }
19095 {
19096 PyThreadState* __tstate = wxPyBeginAllowThreads();
19097 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19098
19099 wxPyEndAllowThreads(__tstate);
19100 if (PyErr_Occurred()) SWIG_fail;
19101 }
19102 {
19103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19104 }
19105 return resultobj;
19106 fail:
19107 return NULL;
19108 }
19109
19110
19111 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19112 PyObject *resultobj;
19113 int arg1 = (int) wxDateTime::Inv_Year ;
19114 int result;
19115 PyObject * obj0 = 0 ;
19116 char *kwnames[] = {
19117 (char *) "year", NULL
19118 };
19119
19120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19121 if (obj0) {
19122 {
19123 arg1 = (int)(SWIG_As_int(obj0));
19124 if (SWIG_arg_fail(1)) SWIG_fail;
19125 }
19126 }
19127 {
19128 PyThreadState* __tstate = wxPyBeginAllowThreads();
19129 result = (int)wxDateTime::GetCentury(arg1);
19130
19131 wxPyEndAllowThreads(__tstate);
19132 if (PyErr_Occurred()) SWIG_fail;
19133 }
19134 {
19135 resultobj = SWIG_From_int((int)(result));
19136 }
19137 return resultobj;
19138 fail:
19139 return NULL;
19140 }
19141
19142
19143 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19144 PyObject *resultobj;
19145 int arg1 ;
19146 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19147 int result;
19148 PyObject * obj0 = 0 ;
19149 PyObject * obj1 = 0 ;
19150 char *kwnames[] = {
19151 (char *) "year",(char *) "cal", NULL
19152 };
19153
19154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19155 {
19156 arg1 = (int)(SWIG_As_int(obj0));
19157 if (SWIG_arg_fail(1)) SWIG_fail;
19158 }
19159 if (obj1) {
19160 {
19161 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19162 if (SWIG_arg_fail(2)) SWIG_fail;
19163 }
19164 }
19165 {
19166 PyThreadState* __tstate = wxPyBeginAllowThreads();
19167 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19168
19169 wxPyEndAllowThreads(__tstate);
19170 if (PyErr_Occurred()) SWIG_fail;
19171 }
19172 {
19173 resultobj = SWIG_From_int((int)(result));
19174 }
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj;
19183 wxDateTime::Month arg1 ;
19184 int arg2 = (int) wxDateTime::Inv_Year ;
19185 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19186 int result;
19187 PyObject * obj0 = 0 ;
19188 PyObject * obj1 = 0 ;
19189 PyObject * obj2 = 0 ;
19190 char *kwnames[] = {
19191 (char *) "month",(char *) "year",(char *) "cal", NULL
19192 };
19193
19194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19195 {
19196 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19197 if (SWIG_arg_fail(1)) SWIG_fail;
19198 }
19199 if (obj1) {
19200 {
19201 arg2 = (int)(SWIG_As_int(obj1));
19202 if (SWIG_arg_fail(2)) SWIG_fail;
19203 }
19204 }
19205 if (obj2) {
19206 {
19207 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19208 if (SWIG_arg_fail(3)) SWIG_fail;
19209 }
19210 }
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19214
19215 wxPyEndAllowThreads(__tstate);
19216 if (PyErr_Occurred()) SWIG_fail;
19217 }
19218 {
19219 resultobj = SWIG_From_int((int)(result));
19220 }
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19228 PyObject *resultobj;
19229 wxDateTime::Month arg1 ;
19230 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19231 wxString result;
19232 PyObject * obj0 = 0 ;
19233 PyObject * obj1 = 0 ;
19234 char *kwnames[] = {
19235 (char *) "month",(char *) "flags", NULL
19236 };
19237
19238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19239 {
19240 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19241 if (SWIG_arg_fail(1)) SWIG_fail;
19242 }
19243 if (obj1) {
19244 {
19245 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19246 if (SWIG_arg_fail(2)) SWIG_fail;
19247 }
19248 }
19249 {
19250 PyThreadState* __tstate = wxPyBeginAllowThreads();
19251 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19252
19253 wxPyEndAllowThreads(__tstate);
19254 if (PyErr_Occurred()) SWIG_fail;
19255 }
19256 {
19257 #if wxUSE_UNICODE
19258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19259 #else
19260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19261 #endif
19262 }
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19270 PyObject *resultobj;
19271 wxDateTime::WeekDay arg1 ;
19272 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19273 wxString result;
19274 PyObject * obj0 = 0 ;
19275 PyObject * obj1 = 0 ;
19276 char *kwnames[] = {
19277 (char *) "weekday",(char *) "flags", NULL
19278 };
19279
19280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19281 {
19282 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19283 if (SWIG_arg_fail(1)) SWIG_fail;
19284 }
19285 if (obj1) {
19286 {
19287 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19288 if (SWIG_arg_fail(2)) SWIG_fail;
19289 }
19290 }
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19294
19295 wxPyEndAllowThreads(__tstate);
19296 if (PyErr_Occurred()) SWIG_fail;
19297 }
19298 {
19299 #if wxUSE_UNICODE
19300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19301 #else
19302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19303 #endif
19304 }
19305 return resultobj;
19306 fail:
19307 return NULL;
19308 }
19309
19310
19311 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19312 PyObject *resultobj;
19313 PyObject *result;
19314 char *kwnames[] = {
19315 NULL
19316 };
19317
19318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 result = (PyObject *)DateTime_GetAmPmStrings();
19322
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = result;
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj;
19335 int arg1 = (int) wxDateTime::Inv_Year ;
19336 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19337 bool result;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char *kwnames[] = {
19341 (char *) "year",(char *) "country", NULL
19342 };
19343
19344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19345 if (obj0) {
19346 {
19347 arg1 = (int)(SWIG_As_int(obj0));
19348 if (SWIG_arg_fail(1)) SWIG_fail;
19349 }
19350 }
19351 if (obj1) {
19352 {
19353 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19354 if (SWIG_arg_fail(2)) SWIG_fail;
19355 }
19356 }
19357 {
19358 PyThreadState* __tstate = wxPyBeginAllowThreads();
19359 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19360
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 {
19365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19366 }
19367 return resultobj;
19368 fail:
19369 return NULL;
19370 }
19371
19372
19373 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19374 PyObject *resultobj;
19375 int arg1 = (int) wxDateTime::Inv_Year ;
19376 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19377 wxDateTime result;
19378 PyObject * obj0 = 0 ;
19379 PyObject * obj1 = 0 ;
19380 char *kwnames[] = {
19381 (char *) "year",(char *) "country", NULL
19382 };
19383
19384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19385 if (obj0) {
19386 {
19387 arg1 = (int)(SWIG_As_int(obj0));
19388 if (SWIG_arg_fail(1)) SWIG_fail;
19389 }
19390 }
19391 if (obj1) {
19392 {
19393 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19394 if (SWIG_arg_fail(2)) SWIG_fail;
19395 }
19396 }
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19400
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 {
19405 wxDateTime * resultptr;
19406 resultptr = new wxDateTime((wxDateTime &)(result));
19407 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19408 }
19409 return resultobj;
19410 fail:
19411 return NULL;
19412 }
19413
19414
19415 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19416 PyObject *resultobj;
19417 int arg1 = (int) wxDateTime::Inv_Year ;
19418 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19419 wxDateTime result;
19420 PyObject * obj0 = 0 ;
19421 PyObject * obj1 = 0 ;
19422 char *kwnames[] = {
19423 (char *) "year",(char *) "country", NULL
19424 };
19425
19426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19427 if (obj0) {
19428 {
19429 arg1 = (int)(SWIG_As_int(obj0));
19430 if (SWIG_arg_fail(1)) SWIG_fail;
19431 }
19432 }
19433 if (obj1) {
19434 {
19435 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19436 if (SWIG_arg_fail(2)) SWIG_fail;
19437 }
19438 }
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19442
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 {
19447 wxDateTime * resultptr;
19448 resultptr = new wxDateTime((wxDateTime &)(result));
19449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19450 }
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj;
19459 wxDateTime result;
19460 char *kwnames[] = {
19461 NULL
19462 };
19463
19464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19465 {
19466 PyThreadState* __tstate = wxPyBeginAllowThreads();
19467 result = wxDateTime::Now();
19468
19469 wxPyEndAllowThreads(__tstate);
19470 if (PyErr_Occurred()) SWIG_fail;
19471 }
19472 {
19473 wxDateTime * resultptr;
19474 resultptr = new wxDateTime((wxDateTime &)(result));
19475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19476 }
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19484 PyObject *resultobj;
19485 wxDateTime result;
19486 char *kwnames[] = {
19487 NULL
19488 };
19489
19490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = wxDateTime::UNow();
19494
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 {
19499 wxDateTime * resultptr;
19500 resultptr = new wxDateTime((wxDateTime &)(result));
19501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19502 }
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19510 PyObject *resultobj;
19511 wxDateTime result;
19512 char *kwnames[] = {
19513 NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19517 {
19518 PyThreadState* __tstate = wxPyBeginAllowThreads();
19519 result = wxDateTime::Today();
19520
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 {
19525 wxDateTime * resultptr;
19526 resultptr = new wxDateTime((wxDateTime &)(result));
19527 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19528 }
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19536 PyObject *resultobj;
19537 wxDateTime *result;
19538 char *kwnames[] = {
19539 NULL
19540 };
19541
19542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 result = (wxDateTime *)new wxDateTime();
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19551 return resultobj;
19552 fail:
19553 return NULL;
19554 }
19555
19556
19557 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19558 PyObject *resultobj;
19559 time_t arg1 ;
19560 wxDateTime *result;
19561 PyObject * obj0 = 0 ;
19562 char *kwnames[] = {
19563 (char *) "timet", NULL
19564 };
19565
19566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19567 {
19568 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19569 if (SWIG_arg_fail(1)) SWIG_fail;
19570 }
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (wxDateTime *)new wxDateTime(arg1);
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj;
19587 double arg1 ;
19588 wxDateTime *result;
19589 PyObject * obj0 = 0 ;
19590 char *kwnames[] = {
19591 (char *) "jdn", NULL
19592 };
19593
19594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19595 {
19596 arg1 = (double)(SWIG_As_double(obj0));
19597 if (SWIG_arg_fail(1)) SWIG_fail;
19598 }
19599 {
19600 PyThreadState* __tstate = wxPyBeginAllowThreads();
19601 result = (wxDateTime *)new wxDateTime(arg1);
19602
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19614 PyObject *resultobj;
19615 int arg1 ;
19616 int arg2 = (int) 0 ;
19617 int arg3 = (int) 0 ;
19618 int arg4 = (int) 0 ;
19619 wxDateTime *result;
19620 PyObject * obj0 = 0 ;
19621 PyObject * obj1 = 0 ;
19622 PyObject * obj2 = 0 ;
19623 PyObject * obj3 = 0 ;
19624 char *kwnames[] = {
19625 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19626 };
19627
19628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19629 {
19630 arg1 = (int)(SWIG_As_int(obj0));
19631 if (SWIG_arg_fail(1)) SWIG_fail;
19632 }
19633 if (obj1) {
19634 {
19635 arg2 = (int)(SWIG_As_int(obj1));
19636 if (SWIG_arg_fail(2)) SWIG_fail;
19637 }
19638 }
19639 if (obj2) {
19640 {
19641 arg3 = (int)(SWIG_As_int(obj2));
19642 if (SWIG_arg_fail(3)) SWIG_fail;
19643 }
19644 }
19645 if (obj3) {
19646 {
19647 arg4 = (int)(SWIG_As_int(obj3));
19648 if (SWIG_arg_fail(4)) SWIG_fail;
19649 }
19650 }
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19654
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj;
19667 int arg1 ;
19668 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19669 int arg3 = (int) wxDateTime::Inv_Year ;
19670 int arg4 = (int) 0 ;
19671 int arg5 = (int) 0 ;
19672 int arg6 = (int) 0 ;
19673 int arg7 = (int) 0 ;
19674 wxDateTime *result;
19675 PyObject * obj0 = 0 ;
19676 PyObject * obj1 = 0 ;
19677 PyObject * obj2 = 0 ;
19678 PyObject * obj3 = 0 ;
19679 PyObject * obj4 = 0 ;
19680 PyObject * obj5 = 0 ;
19681 PyObject * obj6 = 0 ;
19682 char *kwnames[] = {
19683 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19684 };
19685
19686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19687 {
19688 arg1 = (int)(SWIG_As_int(obj0));
19689 if (SWIG_arg_fail(1)) SWIG_fail;
19690 }
19691 if (obj1) {
19692 {
19693 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19694 if (SWIG_arg_fail(2)) SWIG_fail;
19695 }
19696 }
19697 if (obj2) {
19698 {
19699 arg3 = (int)(SWIG_As_int(obj2));
19700 if (SWIG_arg_fail(3)) SWIG_fail;
19701 }
19702 }
19703 if (obj3) {
19704 {
19705 arg4 = (int)(SWIG_As_int(obj3));
19706 if (SWIG_arg_fail(4)) SWIG_fail;
19707 }
19708 }
19709 if (obj4) {
19710 {
19711 arg5 = (int)(SWIG_As_int(obj4));
19712 if (SWIG_arg_fail(5)) SWIG_fail;
19713 }
19714 }
19715 if (obj5) {
19716 {
19717 arg6 = (int)(SWIG_As_int(obj5));
19718 if (SWIG_arg_fail(6)) SWIG_fail;
19719 }
19720 }
19721 if (obj6) {
19722 {
19723 arg7 = (int)(SWIG_As_int(obj6));
19724 if (SWIG_arg_fail(7)) SWIG_fail;
19725 }
19726 }
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19730
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 wxDateTime *arg1 = (wxDateTime *) 0 ;
19744 PyObject * obj0 = 0 ;
19745 char *kwnames[] = {
19746 (char *) "self", NULL
19747 };
19748
19749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19751 if (SWIG_arg_fail(1)) SWIG_fail;
19752 {
19753 PyThreadState* __tstate = wxPyBeginAllowThreads();
19754 delete arg1;
19755
19756 wxPyEndAllowThreads(__tstate);
19757 if (PyErr_Occurred()) SWIG_fail;
19758 }
19759 Py_INCREF(Py_None); resultobj = Py_None;
19760 return resultobj;
19761 fail:
19762 return NULL;
19763 }
19764
19765
19766 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19767 PyObject *resultobj;
19768 wxDateTime *arg1 = (wxDateTime *) 0 ;
19769 wxDateTime *result;
19770 PyObject * obj0 = 0 ;
19771 char *kwnames[] = {
19772 (char *) "self", NULL
19773 };
19774
19775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19777 if (SWIG_arg_fail(1)) SWIG_fail;
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 {
19781 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19782 result = (wxDateTime *) &_result_ref;
19783 }
19784
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19789 return resultobj;
19790 fail:
19791 return NULL;
19792 }
19793
19794
19795 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19796 PyObject *resultobj;
19797 wxDateTime *arg1 = (wxDateTime *) 0 ;
19798 time_t arg2 ;
19799 wxDateTime *result;
19800 PyObject * obj0 = 0 ;
19801 PyObject * obj1 = 0 ;
19802 char *kwnames[] = {
19803 (char *) "self",(char *) "timet", NULL
19804 };
19805
19806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19808 if (SWIG_arg_fail(1)) SWIG_fail;
19809 {
19810 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19811 if (SWIG_arg_fail(2)) SWIG_fail;
19812 }
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 {
19816 wxDateTime &_result_ref = (arg1)->Set(arg2);
19817 result = (wxDateTime *) &_result_ref;
19818 }
19819
19820 wxPyEndAllowThreads(__tstate);
19821 if (PyErr_Occurred()) SWIG_fail;
19822 }
19823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19824 return resultobj;
19825 fail:
19826 return NULL;
19827 }
19828
19829
19830 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19831 PyObject *resultobj;
19832 wxDateTime *arg1 = (wxDateTime *) 0 ;
19833 double arg2 ;
19834 wxDateTime *result;
19835 PyObject * obj0 = 0 ;
19836 PyObject * obj1 = 0 ;
19837 char *kwnames[] = {
19838 (char *) "self",(char *) "jdn", NULL
19839 };
19840
19841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19843 if (SWIG_arg_fail(1)) SWIG_fail;
19844 {
19845 arg2 = (double)(SWIG_As_double(obj1));
19846 if (SWIG_arg_fail(2)) SWIG_fail;
19847 }
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 {
19851 wxDateTime &_result_ref = (arg1)->Set(arg2);
19852 result = (wxDateTime *) &_result_ref;
19853 }
19854
19855 wxPyEndAllowThreads(__tstate);
19856 if (PyErr_Occurred()) SWIG_fail;
19857 }
19858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj;
19867 wxDateTime *arg1 = (wxDateTime *) 0 ;
19868 int arg2 ;
19869 int arg3 = (int) 0 ;
19870 int arg4 = (int) 0 ;
19871 int arg5 = (int) 0 ;
19872 wxDateTime *result;
19873 PyObject * obj0 = 0 ;
19874 PyObject * obj1 = 0 ;
19875 PyObject * obj2 = 0 ;
19876 PyObject * obj3 = 0 ;
19877 PyObject * obj4 = 0 ;
19878 char *kwnames[] = {
19879 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19880 };
19881
19882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19884 if (SWIG_arg_fail(1)) SWIG_fail;
19885 {
19886 arg2 = (int)(SWIG_As_int(obj1));
19887 if (SWIG_arg_fail(2)) SWIG_fail;
19888 }
19889 if (obj2) {
19890 {
19891 arg3 = (int)(SWIG_As_int(obj2));
19892 if (SWIG_arg_fail(3)) SWIG_fail;
19893 }
19894 }
19895 if (obj3) {
19896 {
19897 arg4 = (int)(SWIG_As_int(obj3));
19898 if (SWIG_arg_fail(4)) SWIG_fail;
19899 }
19900 }
19901 if (obj4) {
19902 {
19903 arg5 = (int)(SWIG_As_int(obj4));
19904 if (SWIG_arg_fail(5)) SWIG_fail;
19905 }
19906 }
19907 {
19908 PyThreadState* __tstate = wxPyBeginAllowThreads();
19909 {
19910 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19911 result = (wxDateTime *) &_result_ref;
19912 }
19913
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19925 PyObject *resultobj;
19926 wxDateTime *arg1 = (wxDateTime *) 0 ;
19927 int arg2 ;
19928 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19929 int arg4 = (int) wxDateTime::Inv_Year ;
19930 int arg5 = (int) 0 ;
19931 int arg6 = (int) 0 ;
19932 int arg7 = (int) 0 ;
19933 int arg8 = (int) 0 ;
19934 wxDateTime *result;
19935 PyObject * obj0 = 0 ;
19936 PyObject * obj1 = 0 ;
19937 PyObject * obj2 = 0 ;
19938 PyObject * obj3 = 0 ;
19939 PyObject * obj4 = 0 ;
19940 PyObject * obj5 = 0 ;
19941 PyObject * obj6 = 0 ;
19942 PyObject * obj7 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19949 if (SWIG_arg_fail(1)) SWIG_fail;
19950 {
19951 arg2 = (int)(SWIG_As_int(obj1));
19952 if (SWIG_arg_fail(2)) SWIG_fail;
19953 }
19954 if (obj2) {
19955 {
19956 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19957 if (SWIG_arg_fail(3)) SWIG_fail;
19958 }
19959 }
19960 if (obj3) {
19961 {
19962 arg4 = (int)(SWIG_As_int(obj3));
19963 if (SWIG_arg_fail(4)) SWIG_fail;
19964 }
19965 }
19966 if (obj4) {
19967 {
19968 arg5 = (int)(SWIG_As_int(obj4));
19969 if (SWIG_arg_fail(5)) SWIG_fail;
19970 }
19971 }
19972 if (obj5) {
19973 {
19974 arg6 = (int)(SWIG_As_int(obj5));
19975 if (SWIG_arg_fail(6)) SWIG_fail;
19976 }
19977 }
19978 if (obj6) {
19979 {
19980 arg7 = (int)(SWIG_As_int(obj6));
19981 if (SWIG_arg_fail(7)) SWIG_fail;
19982 }
19983 }
19984 if (obj7) {
19985 {
19986 arg8 = (int)(SWIG_As_int(obj7));
19987 if (SWIG_arg_fail(8)) SWIG_fail;
19988 }
19989 }
19990 {
19991 PyThreadState* __tstate = wxPyBeginAllowThreads();
19992 {
19993 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19994 result = (wxDateTime *) &_result_ref;
19995 }
19996
19997 wxPyEndAllowThreads(__tstate);
19998 if (PyErr_Occurred()) SWIG_fail;
19999 }
20000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20008 PyObject *resultobj;
20009 wxDateTime *arg1 = (wxDateTime *) 0 ;
20010 wxDateTime *result;
20011 PyObject * obj0 = 0 ;
20012 char *kwnames[] = {
20013 (char *) "self", NULL
20014 };
20015
20016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20018 if (SWIG_arg_fail(1)) SWIG_fail;
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 {
20022 wxDateTime &_result_ref = (arg1)->ResetTime();
20023 result = (wxDateTime *) &_result_ref;
20024 }
20025
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20037 PyObject *resultobj;
20038 wxDateTime *arg1 = (wxDateTime *) 0 ;
20039 int arg2 ;
20040 wxDateTime *result;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char *kwnames[] = {
20044 (char *) "self",(char *) "year", NULL
20045 };
20046
20047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20049 if (SWIG_arg_fail(1)) SWIG_fail;
20050 {
20051 arg2 = (int)(SWIG_As_int(obj1));
20052 if (SWIG_arg_fail(2)) SWIG_fail;
20053 }
20054 {
20055 PyThreadState* __tstate = wxPyBeginAllowThreads();
20056 {
20057 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20058 result = (wxDateTime *) &_result_ref;
20059 }
20060
20061 wxPyEndAllowThreads(__tstate);
20062 if (PyErr_Occurred()) SWIG_fail;
20063 }
20064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20065 return resultobj;
20066 fail:
20067 return NULL;
20068 }
20069
20070
20071 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20072 PyObject *resultobj;
20073 wxDateTime *arg1 = (wxDateTime *) 0 ;
20074 wxDateTime::Month arg2 ;
20075 wxDateTime *result;
20076 PyObject * obj0 = 0 ;
20077 PyObject * obj1 = 0 ;
20078 char *kwnames[] = {
20079 (char *) "self",(char *) "month", NULL
20080 };
20081
20082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20084 if (SWIG_arg_fail(1)) SWIG_fail;
20085 {
20086 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20087 if (SWIG_arg_fail(2)) SWIG_fail;
20088 }
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 {
20092 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20093 result = (wxDateTime *) &_result_ref;
20094 }
20095
20096 wxPyEndAllowThreads(__tstate);
20097 if (PyErr_Occurred()) SWIG_fail;
20098 }
20099 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20100 return resultobj;
20101 fail:
20102 return NULL;
20103 }
20104
20105
20106 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20107 PyObject *resultobj;
20108 wxDateTime *arg1 = (wxDateTime *) 0 ;
20109 int arg2 ;
20110 wxDateTime *result;
20111 PyObject * obj0 = 0 ;
20112 PyObject * obj1 = 0 ;
20113 char *kwnames[] = {
20114 (char *) "self",(char *) "day", NULL
20115 };
20116
20117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20119 if (SWIG_arg_fail(1)) SWIG_fail;
20120 {
20121 arg2 = (int)(SWIG_As_int(obj1));
20122 if (SWIG_arg_fail(2)) SWIG_fail;
20123 }
20124 {
20125 PyThreadState* __tstate = wxPyBeginAllowThreads();
20126 {
20127 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20128 result = (wxDateTime *) &_result_ref;
20129 }
20130
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20142 PyObject *resultobj;
20143 wxDateTime *arg1 = (wxDateTime *) 0 ;
20144 int arg2 ;
20145 wxDateTime *result;
20146 PyObject * obj0 = 0 ;
20147 PyObject * obj1 = 0 ;
20148 char *kwnames[] = {
20149 (char *) "self",(char *) "hour", NULL
20150 };
20151
20152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20154 if (SWIG_arg_fail(1)) SWIG_fail;
20155 {
20156 arg2 = (int)(SWIG_As_int(obj1));
20157 if (SWIG_arg_fail(2)) SWIG_fail;
20158 }
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 {
20162 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20163 result = (wxDateTime *) &_result_ref;
20164 }
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxDateTime *arg1 = (wxDateTime *) 0 ;
20179 int arg2 ;
20180 wxDateTime *result;
20181 PyObject * obj0 = 0 ;
20182 PyObject * obj1 = 0 ;
20183 char *kwnames[] = {
20184 (char *) "self",(char *) "minute", NULL
20185 };
20186
20187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20189 if (SWIG_arg_fail(1)) SWIG_fail;
20190 {
20191 arg2 = (int)(SWIG_As_int(obj1));
20192 if (SWIG_arg_fail(2)) SWIG_fail;
20193 }
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 {
20197 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20198 result = (wxDateTime *) &_result_ref;
20199 }
20200
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj;
20213 wxDateTime *arg1 = (wxDateTime *) 0 ;
20214 int arg2 ;
20215 wxDateTime *result;
20216 PyObject * obj0 = 0 ;
20217 PyObject * obj1 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self",(char *) "second", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 {
20226 arg2 = (int)(SWIG_As_int(obj1));
20227 if (SWIG_arg_fail(2)) SWIG_fail;
20228 }
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 {
20232 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20233 result = (wxDateTime *) &_result_ref;
20234 }
20235
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj;
20248 wxDateTime *arg1 = (wxDateTime *) 0 ;
20249 int arg2 ;
20250 wxDateTime *result;
20251 PyObject * obj0 = 0 ;
20252 PyObject * obj1 = 0 ;
20253 char *kwnames[] = {
20254 (char *) "self",(char *) "millisecond", NULL
20255 };
20256
20257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20259 if (SWIG_arg_fail(1)) SWIG_fail;
20260 {
20261 arg2 = (int)(SWIG_As_int(obj1));
20262 if (SWIG_arg_fail(2)) SWIG_fail;
20263 }
20264 {
20265 PyThreadState* __tstate = wxPyBeginAllowThreads();
20266 {
20267 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20268 result = (wxDateTime *) &_result_ref;
20269 }
20270
20271 wxPyEndAllowThreads(__tstate);
20272 if (PyErr_Occurred()) SWIG_fail;
20273 }
20274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20275 return resultobj;
20276 fail:
20277 return NULL;
20278 }
20279
20280
20281 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20282 PyObject *resultobj;
20283 wxDateTime *arg1 = (wxDateTime *) 0 ;
20284 wxDateTime::WeekDay arg2 ;
20285 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20286 wxDateTime *result;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 PyObject * obj2 = 0 ;
20290 char *kwnames[] = {
20291 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20292 };
20293
20294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20296 if (SWIG_arg_fail(1)) SWIG_fail;
20297 {
20298 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20299 if (SWIG_arg_fail(2)) SWIG_fail;
20300 }
20301 if (obj2) {
20302 {
20303 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20304 if (SWIG_arg_fail(3)) SWIG_fail;
20305 }
20306 }
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 {
20310 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20311 result = (wxDateTime *) &_result_ref;
20312 }
20313
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20325 PyObject *resultobj;
20326 wxDateTime *arg1 = (wxDateTime *) 0 ;
20327 wxDateTime::WeekDay arg2 ;
20328 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20329 wxDateTime result;
20330 PyObject * obj0 = 0 ;
20331 PyObject * obj1 = 0 ;
20332 PyObject * obj2 = 0 ;
20333 char *kwnames[] = {
20334 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20335 };
20336
20337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20339 if (SWIG_arg_fail(1)) SWIG_fail;
20340 {
20341 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20342 if (SWIG_arg_fail(2)) SWIG_fail;
20343 }
20344 if (obj2) {
20345 {
20346 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20347 if (SWIG_arg_fail(3)) SWIG_fail;
20348 }
20349 }
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20353
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 wxDateTime * resultptr;
20359 resultptr = new wxDateTime((wxDateTime &)(result));
20360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj;
20370 wxDateTime *arg1 = (wxDateTime *) 0 ;
20371 wxDateTime::WeekDay arg2 ;
20372 wxDateTime *result;
20373 PyObject * obj0 = 0 ;
20374 PyObject * obj1 = 0 ;
20375 char *kwnames[] = {
20376 (char *) "self",(char *) "weekday", NULL
20377 };
20378
20379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20381 if (SWIG_arg_fail(1)) SWIG_fail;
20382 {
20383 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20384 if (SWIG_arg_fail(2)) SWIG_fail;
20385 }
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 {
20389 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20390 result = (wxDateTime *) &_result_ref;
20391 }
20392
20393 wxPyEndAllowThreads(__tstate);
20394 if (PyErr_Occurred()) SWIG_fail;
20395 }
20396 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20397 return resultobj;
20398 fail:
20399 return NULL;
20400 }
20401
20402
20403 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20404 PyObject *resultobj;
20405 wxDateTime *arg1 = (wxDateTime *) 0 ;
20406 wxDateTime::WeekDay arg2 ;
20407 wxDateTime result;
20408 PyObject * obj0 = 0 ;
20409 PyObject * obj1 = 0 ;
20410 char *kwnames[] = {
20411 (char *) "self",(char *) "weekday", NULL
20412 };
20413
20414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20416 if (SWIG_arg_fail(1)) SWIG_fail;
20417 {
20418 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20419 if (SWIG_arg_fail(2)) SWIG_fail;
20420 }
20421 {
20422 PyThreadState* __tstate = wxPyBeginAllowThreads();
20423 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20424
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 {
20429 wxDateTime * resultptr;
20430 resultptr = new wxDateTime((wxDateTime &)(result));
20431 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20432 }
20433 return resultobj;
20434 fail:
20435 return NULL;
20436 }
20437
20438
20439 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20440 PyObject *resultobj;
20441 wxDateTime *arg1 = (wxDateTime *) 0 ;
20442 wxDateTime::WeekDay arg2 ;
20443 wxDateTime *result;
20444 PyObject * obj0 = 0 ;
20445 PyObject * obj1 = 0 ;
20446 char *kwnames[] = {
20447 (char *) "self",(char *) "weekday", NULL
20448 };
20449
20450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20452 if (SWIG_arg_fail(1)) SWIG_fail;
20453 {
20454 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20455 if (SWIG_arg_fail(2)) SWIG_fail;
20456 }
20457 {
20458 PyThreadState* __tstate = wxPyBeginAllowThreads();
20459 {
20460 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20461 result = (wxDateTime *) &_result_ref;
20462 }
20463
20464 wxPyEndAllowThreads(__tstate);
20465 if (PyErr_Occurred()) SWIG_fail;
20466 }
20467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 wxDateTime *arg1 = (wxDateTime *) 0 ;
20477 wxDateTime::WeekDay arg2 ;
20478 wxDateTime result;
20479 PyObject * obj0 = 0 ;
20480 PyObject * obj1 = 0 ;
20481 char *kwnames[] = {
20482 (char *) "self",(char *) "weekday", NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20487 if (SWIG_arg_fail(1)) SWIG_fail;
20488 {
20489 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20490 if (SWIG_arg_fail(2)) SWIG_fail;
20491 }
20492 {
20493 PyThreadState* __tstate = wxPyBeginAllowThreads();
20494 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20495
20496 wxPyEndAllowThreads(__tstate);
20497 if (PyErr_Occurred()) SWIG_fail;
20498 }
20499 {
20500 wxDateTime * resultptr;
20501 resultptr = new wxDateTime((wxDateTime &)(result));
20502 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20503 }
20504 return resultobj;
20505 fail:
20506 return NULL;
20507 }
20508
20509
20510 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20511 PyObject *resultobj;
20512 wxDateTime *arg1 = (wxDateTime *) 0 ;
20513 wxDateTime::WeekDay arg2 ;
20514 int arg3 = (int) 1 ;
20515 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20516 int arg5 = (int) wxDateTime::Inv_Year ;
20517 bool result;
20518 PyObject * obj0 = 0 ;
20519 PyObject * obj1 = 0 ;
20520 PyObject * obj2 = 0 ;
20521 PyObject * obj3 = 0 ;
20522 PyObject * obj4 = 0 ;
20523 char *kwnames[] = {
20524 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20525 };
20526
20527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20529 if (SWIG_arg_fail(1)) SWIG_fail;
20530 {
20531 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20532 if (SWIG_arg_fail(2)) SWIG_fail;
20533 }
20534 if (obj2) {
20535 {
20536 arg3 = (int)(SWIG_As_int(obj2));
20537 if (SWIG_arg_fail(3)) SWIG_fail;
20538 }
20539 }
20540 if (obj3) {
20541 {
20542 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20543 if (SWIG_arg_fail(4)) SWIG_fail;
20544 }
20545 }
20546 if (obj4) {
20547 {
20548 arg5 = (int)(SWIG_As_int(obj4));
20549 if (SWIG_arg_fail(5)) SWIG_fail;
20550 }
20551 }
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20555
20556 wxPyEndAllowThreads(__tstate);
20557 if (PyErr_Occurred()) SWIG_fail;
20558 }
20559 {
20560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20561 }
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20569 PyObject *resultobj;
20570 wxDateTime *arg1 = (wxDateTime *) 0 ;
20571 wxDateTime::WeekDay arg2 ;
20572 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20573 int arg4 = (int) wxDateTime::Inv_Year ;
20574 bool result;
20575 PyObject * obj0 = 0 ;
20576 PyObject * obj1 = 0 ;
20577 PyObject * obj2 = 0 ;
20578 PyObject * obj3 = 0 ;
20579 char *kwnames[] = {
20580 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20581 };
20582
20583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20585 if (SWIG_arg_fail(1)) SWIG_fail;
20586 {
20587 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20588 if (SWIG_arg_fail(2)) SWIG_fail;
20589 }
20590 if (obj2) {
20591 {
20592 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20593 if (SWIG_arg_fail(3)) SWIG_fail;
20594 }
20595 }
20596 if (obj3) {
20597 {
20598 arg4 = (int)(SWIG_As_int(obj3));
20599 if (SWIG_arg_fail(4)) SWIG_fail;
20600 }
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20605
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 {
20610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20611 }
20612 return resultobj;
20613 fail:
20614 return NULL;
20615 }
20616
20617
20618 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20619 PyObject *resultobj;
20620 wxDateTime *arg1 = (wxDateTime *) 0 ;
20621 wxDateTime::WeekDay arg2 ;
20622 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20623 int arg4 = (int) wxDateTime::Inv_Year ;
20624 wxDateTime result;
20625 PyObject * obj0 = 0 ;
20626 PyObject * obj1 = 0 ;
20627 PyObject * obj2 = 0 ;
20628 PyObject * obj3 = 0 ;
20629 char *kwnames[] = {
20630 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20631 };
20632
20633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20635 if (SWIG_arg_fail(1)) SWIG_fail;
20636 {
20637 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20638 if (SWIG_arg_fail(2)) SWIG_fail;
20639 }
20640 if (obj2) {
20641 {
20642 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20643 if (SWIG_arg_fail(3)) SWIG_fail;
20644 }
20645 }
20646 if (obj3) {
20647 {
20648 arg4 = (int)(SWIG_As_int(obj3));
20649 if (SWIG_arg_fail(4)) SWIG_fail;
20650 }
20651 }
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20655
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 {
20660 wxDateTime * resultptr;
20661 resultptr = new wxDateTime((wxDateTime &)(result));
20662 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20663 }
20664 return resultobj;
20665 fail:
20666 return NULL;
20667 }
20668
20669
20670 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20671 PyObject *resultobj;
20672 wxDateTime *arg1 = (wxDateTime *) 0 ;
20673 int arg2 ;
20674 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20675 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20676 bool result;
20677 PyObject * obj0 = 0 ;
20678 PyObject * obj1 = 0 ;
20679 PyObject * obj2 = 0 ;
20680 PyObject * obj3 = 0 ;
20681 char *kwnames[] = {
20682 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20683 };
20684
20685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20687 if (SWIG_arg_fail(1)) SWIG_fail;
20688 {
20689 arg2 = (int)(SWIG_As_int(obj1));
20690 if (SWIG_arg_fail(2)) SWIG_fail;
20691 }
20692 if (obj2) {
20693 {
20694 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20695 if (SWIG_arg_fail(3)) SWIG_fail;
20696 }
20697 }
20698 if (obj3) {
20699 {
20700 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20701 if (SWIG_arg_fail(4)) SWIG_fail;
20702 }
20703 }
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20707
20708 wxPyEndAllowThreads(__tstate);
20709 if (PyErr_Occurred()) SWIG_fail;
20710 }
20711 {
20712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20713 }
20714 return resultobj;
20715 fail:
20716 return NULL;
20717 }
20718
20719
20720 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20721 PyObject *resultobj;
20722 wxDateTime *arg1 = (wxDateTime *) 0 ;
20723 int arg2 ;
20724 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20725 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20726 wxDateTime result;
20727 PyObject * obj0 = 0 ;
20728 PyObject * obj1 = 0 ;
20729 PyObject * obj2 = 0 ;
20730 PyObject * obj3 = 0 ;
20731 char *kwnames[] = {
20732 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(1)) SWIG_fail;
20738 {
20739 arg2 = (int)(SWIG_As_int(obj1));
20740 if (SWIG_arg_fail(2)) SWIG_fail;
20741 }
20742 if (obj2) {
20743 {
20744 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20745 if (SWIG_arg_fail(3)) SWIG_fail;
20746 }
20747 }
20748 if (obj3) {
20749 {
20750 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20751 if (SWIG_arg_fail(4)) SWIG_fail;
20752 }
20753 }
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20757
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 {
20762 wxDateTime * resultptr;
20763 resultptr = new wxDateTime((wxDateTime &)(result));
20764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20765 }
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20773 PyObject *resultobj;
20774 int arg1 ;
20775 int arg2 ;
20776 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20777 wxDateTime result;
20778 PyObject * obj0 = 0 ;
20779 PyObject * obj1 = 0 ;
20780 PyObject * obj2 = 0 ;
20781 char *kwnames[] = {
20782 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20783 };
20784
20785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20786 {
20787 arg1 = (int)(SWIG_As_int(obj0));
20788 if (SWIG_arg_fail(1)) SWIG_fail;
20789 }
20790 {
20791 arg2 = (int)(SWIG_As_int(obj1));
20792 if (SWIG_arg_fail(2)) SWIG_fail;
20793 }
20794 if (obj2) {
20795 {
20796 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20797 if (SWIG_arg_fail(3)) SWIG_fail;
20798 }
20799 }
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20803
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 wxDateTime * resultptr;
20809 resultptr = new wxDateTime((wxDateTime &)(result));
20810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20811 }
20812 return resultobj;
20813 fail:
20814 return NULL;
20815 }
20816
20817
20818 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20819 PyObject *resultobj;
20820 wxDateTime *arg1 = (wxDateTime *) 0 ;
20821 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20822 int arg3 = (int) wxDateTime::Inv_Year ;
20823 wxDateTime *result;
20824 PyObject * obj0 = 0 ;
20825 PyObject * obj1 = 0 ;
20826 PyObject * obj2 = 0 ;
20827 char *kwnames[] = {
20828 (char *) "self",(char *) "month",(char *) "year", NULL
20829 };
20830
20831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20833 if (SWIG_arg_fail(1)) SWIG_fail;
20834 if (obj1) {
20835 {
20836 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20837 if (SWIG_arg_fail(2)) SWIG_fail;
20838 }
20839 }
20840 if (obj2) {
20841 {
20842 arg3 = (int)(SWIG_As_int(obj2));
20843 if (SWIG_arg_fail(3)) SWIG_fail;
20844 }
20845 }
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 {
20849 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20850 result = (wxDateTime *) &_result_ref;
20851 }
20852
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20857 return resultobj;
20858 fail:
20859 return NULL;
20860 }
20861
20862
20863 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20864 PyObject *resultobj;
20865 wxDateTime *arg1 = (wxDateTime *) 0 ;
20866 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20867 int arg3 = (int) wxDateTime::Inv_Year ;
20868 wxDateTime result;
20869 PyObject * obj0 = 0 ;
20870 PyObject * obj1 = 0 ;
20871 PyObject * obj2 = 0 ;
20872 char *kwnames[] = {
20873 (char *) "self",(char *) "month",(char *) "year", NULL
20874 };
20875
20876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20878 if (SWIG_arg_fail(1)) SWIG_fail;
20879 if (obj1) {
20880 {
20881 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20882 if (SWIG_arg_fail(2)) SWIG_fail;
20883 }
20884 }
20885 if (obj2) {
20886 {
20887 arg3 = (int)(SWIG_As_int(obj2));
20888 if (SWIG_arg_fail(3)) SWIG_fail;
20889 }
20890 }
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20894
20895 wxPyEndAllowThreads(__tstate);
20896 if (PyErr_Occurred()) SWIG_fail;
20897 }
20898 {
20899 wxDateTime * resultptr;
20900 resultptr = new wxDateTime((wxDateTime &)(result));
20901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20902 }
20903 return resultobj;
20904 fail:
20905 return NULL;
20906 }
20907
20908
20909 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20910 PyObject *resultobj;
20911 wxDateTime *arg1 = (wxDateTime *) 0 ;
20912 int arg2 ;
20913 wxDateTime *result;
20914 PyObject * obj0 = 0 ;
20915 PyObject * obj1 = 0 ;
20916 char *kwnames[] = {
20917 (char *) "self",(char *) "yday", NULL
20918 };
20919
20920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20922 if (SWIG_arg_fail(1)) SWIG_fail;
20923 {
20924 arg2 = (int)(SWIG_As_int(obj1));
20925 if (SWIG_arg_fail(2)) SWIG_fail;
20926 }
20927 {
20928 PyThreadState* __tstate = wxPyBeginAllowThreads();
20929 {
20930 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20931 result = (wxDateTime *) &_result_ref;
20932 }
20933
20934 wxPyEndAllowThreads(__tstate);
20935 if (PyErr_Occurred()) SWIG_fail;
20936 }
20937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20938 return resultobj;
20939 fail:
20940 return NULL;
20941 }
20942
20943
20944 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20945 PyObject *resultobj;
20946 wxDateTime *arg1 = (wxDateTime *) 0 ;
20947 int arg2 ;
20948 wxDateTime result;
20949 PyObject * obj0 = 0 ;
20950 PyObject * obj1 = 0 ;
20951 char *kwnames[] = {
20952 (char *) "self",(char *) "yday", NULL
20953 };
20954
20955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20957 if (SWIG_arg_fail(1)) SWIG_fail;
20958 {
20959 arg2 = (int)(SWIG_As_int(obj1));
20960 if (SWIG_arg_fail(2)) SWIG_fail;
20961 }
20962 {
20963 PyThreadState* __tstate = wxPyBeginAllowThreads();
20964 result = (arg1)->GetYearDay(arg2);
20965
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 {
20970 wxDateTime * resultptr;
20971 resultptr = new wxDateTime((wxDateTime &)(result));
20972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20973 }
20974 return resultobj;
20975 fail:
20976 return NULL;
20977 }
20978
20979
20980 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20981 PyObject *resultobj;
20982 wxDateTime *arg1 = (wxDateTime *) 0 ;
20983 double result;
20984 PyObject * obj0 = 0 ;
20985 char *kwnames[] = {
20986 (char *) "self", NULL
20987 };
20988
20989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20991 if (SWIG_arg_fail(1)) SWIG_fail;
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (double)(arg1)->GetJulianDayNumber();
20995
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 {
21000 resultobj = SWIG_From_double((double)(result));
21001 }
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21009 PyObject *resultobj;
21010 wxDateTime *arg1 = (wxDateTime *) 0 ;
21011 double result;
21012 PyObject * obj0 = 0 ;
21013 char *kwnames[] = {
21014 (char *) "self", NULL
21015 };
21016
21017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21019 if (SWIG_arg_fail(1)) SWIG_fail;
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 result = (double)(arg1)->GetJDN();
21023
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 {
21028 resultobj = SWIG_From_double((double)(result));
21029 }
21030 return resultobj;
21031 fail:
21032 return NULL;
21033 }
21034
21035
21036 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21037 PyObject *resultobj;
21038 wxDateTime *arg1 = (wxDateTime *) 0 ;
21039 double result;
21040 PyObject * obj0 = 0 ;
21041 char *kwnames[] = {
21042 (char *) "self", NULL
21043 };
21044
21045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21047 if (SWIG_arg_fail(1)) SWIG_fail;
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21051
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 {
21056 resultobj = SWIG_From_double((double)(result));
21057 }
21058 return resultobj;
21059 fail:
21060 return NULL;
21061 }
21062
21063
21064 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21065 PyObject *resultobj;
21066 wxDateTime *arg1 = (wxDateTime *) 0 ;
21067 double result;
21068 PyObject * obj0 = 0 ;
21069 char *kwnames[] = {
21070 (char *) "self", NULL
21071 };
21072
21073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21075 if (SWIG_arg_fail(1)) SWIG_fail;
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = (double)(arg1)->GetMJD();
21079
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 {
21084 resultobj = SWIG_From_double((double)(result));
21085 }
21086 return resultobj;
21087 fail:
21088 return NULL;
21089 }
21090
21091
21092 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21093 PyObject *resultobj;
21094 wxDateTime *arg1 = (wxDateTime *) 0 ;
21095 double result;
21096 PyObject * obj0 = 0 ;
21097 char *kwnames[] = {
21098 (char *) "self", NULL
21099 };
21100
21101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21103 if (SWIG_arg_fail(1)) SWIG_fail;
21104 {
21105 PyThreadState* __tstate = wxPyBeginAllowThreads();
21106 result = (double)(arg1)->GetRataDie();
21107
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 {
21112 resultobj = SWIG_From_double((double)(result));
21113 }
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21121 PyObject *resultobj;
21122 wxDateTime *arg1 = (wxDateTime *) 0 ;
21123 wxDateTime::TimeZone *arg2 = 0 ;
21124 bool arg3 = (bool) false ;
21125 wxDateTime result;
21126 bool temp2 = false ;
21127 PyObject * obj0 = 0 ;
21128 PyObject * obj1 = 0 ;
21129 PyObject * obj2 = 0 ;
21130 char *kwnames[] = {
21131 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21132 };
21133
21134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21136 if (SWIG_arg_fail(1)) SWIG_fail;
21137 {
21138 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21139 temp2 = true;
21140 }
21141 if (obj2) {
21142 {
21143 arg3 = (bool)(SWIG_As_bool(obj2));
21144 if (SWIG_arg_fail(3)) SWIG_fail;
21145 }
21146 }
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21150
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 {
21155 wxDateTime * resultptr;
21156 resultptr = new wxDateTime((wxDateTime &)(result));
21157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21158 }
21159 {
21160 if (temp2) delete arg2;
21161 }
21162 return resultobj;
21163 fail:
21164 {
21165 if (temp2) delete arg2;
21166 }
21167 return NULL;
21168 }
21169
21170
21171 static PyObject *_wrap_DateTime_MakeTimezone(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_MakeTimezone",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 {
21201 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21202 result = (wxDateTime *) &_result_ref;
21203 }
21204
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21209 {
21210 if (temp2) delete arg2;
21211 }
21212 return resultobj;
21213 fail:
21214 {
21215 if (temp2) delete arg2;
21216 }
21217 return NULL;
21218 }
21219
21220
21221 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21222 PyObject *resultobj;
21223 wxDateTime *arg1 = (wxDateTime *) 0 ;
21224 bool arg2 = (bool) false ;
21225 wxDateTime result;
21226 PyObject * obj0 = 0 ;
21227 PyObject * obj1 = 0 ;
21228 char *kwnames[] = {
21229 (char *) "self",(char *) "noDST", NULL
21230 };
21231
21232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21234 if (SWIG_arg_fail(1)) SWIG_fail;
21235 if (obj1) {
21236 {
21237 arg2 = (bool)(SWIG_As_bool(obj1));
21238 if (SWIG_arg_fail(2)) SWIG_fail;
21239 }
21240 }
21241 {
21242 PyThreadState* __tstate = wxPyBeginAllowThreads();
21243 result = (arg1)->ToGMT(arg2);
21244
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 {
21249 wxDateTime * resultptr;
21250 resultptr = new wxDateTime((wxDateTime &)(result));
21251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21252 }
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21260 PyObject *resultobj;
21261 wxDateTime *arg1 = (wxDateTime *) 0 ;
21262 bool arg2 = (bool) false ;
21263 wxDateTime *result;
21264 PyObject * obj0 = 0 ;
21265 PyObject * obj1 = 0 ;
21266 char *kwnames[] = {
21267 (char *) "self",(char *) "noDST", NULL
21268 };
21269
21270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21272 if (SWIG_arg_fail(1)) SWIG_fail;
21273 if (obj1) {
21274 {
21275 arg2 = (bool)(SWIG_As_bool(obj1));
21276 if (SWIG_arg_fail(2)) SWIG_fail;
21277 }
21278 }
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 {
21282 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21283 result = (wxDateTime *) &_result_ref;
21284 }
21285
21286 wxPyEndAllowThreads(__tstate);
21287 if (PyErr_Occurred()) SWIG_fail;
21288 }
21289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21290 return resultobj;
21291 fail:
21292 return NULL;
21293 }
21294
21295
21296 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21297 PyObject *resultobj;
21298 wxDateTime *arg1 = (wxDateTime *) 0 ;
21299 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21300 int result;
21301 PyObject * obj0 = 0 ;
21302 PyObject * obj1 = 0 ;
21303 char *kwnames[] = {
21304 (char *) "self",(char *) "country", NULL
21305 };
21306
21307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21309 if (SWIG_arg_fail(1)) SWIG_fail;
21310 if (obj1) {
21311 {
21312 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21313 if (SWIG_arg_fail(2)) SWIG_fail;
21314 }
21315 }
21316 {
21317 PyThreadState* __tstate = wxPyBeginAllowThreads();
21318 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21319
21320 wxPyEndAllowThreads(__tstate);
21321 if (PyErr_Occurred()) SWIG_fail;
21322 }
21323 {
21324 resultobj = SWIG_From_int((int)(result));
21325 }
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj;
21334 wxDateTime *arg1 = (wxDateTime *) 0 ;
21335 bool result;
21336 PyObject * obj0 = 0 ;
21337 char *kwnames[] = {
21338 (char *) "self", NULL
21339 };
21340
21341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21343 if (SWIG_arg_fail(1)) SWIG_fail;
21344 {
21345 PyThreadState* __tstate = wxPyBeginAllowThreads();
21346 result = (bool)((wxDateTime const *)arg1)->IsValid();
21347
21348 wxPyEndAllowThreads(__tstate);
21349 if (PyErr_Occurred()) SWIG_fail;
21350 }
21351 {
21352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21353 }
21354 return resultobj;
21355 fail:
21356 return NULL;
21357 }
21358
21359
21360 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21361 PyObject *resultobj;
21362 wxDateTime *arg1 = (wxDateTime *) 0 ;
21363 time_t result;
21364 PyObject * obj0 = 0 ;
21365 char *kwnames[] = {
21366 (char *) "self", NULL
21367 };
21368
21369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21371 if (SWIG_arg_fail(1)) SWIG_fail;
21372 {
21373 PyThreadState* __tstate = wxPyBeginAllowThreads();
21374 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21375
21376 wxPyEndAllowThreads(__tstate);
21377 if (PyErr_Occurred()) SWIG_fail;
21378 }
21379 {
21380 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21381 }
21382 return resultobj;
21383 fail:
21384 return NULL;
21385 }
21386
21387
21388 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21389 PyObject *resultobj;
21390 wxDateTime *arg1 = (wxDateTime *) 0 ;
21391 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21392 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21393 int result;
21394 bool temp2 = false ;
21395 PyObject * obj0 = 0 ;
21396 PyObject * obj1 = 0 ;
21397 char *kwnames[] = {
21398 (char *) "self",(char *) "tz", NULL
21399 };
21400
21401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21403 if (SWIG_arg_fail(1)) SWIG_fail;
21404 if (obj1) {
21405 {
21406 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21407 temp2 = true;
21408 }
21409 }
21410 {
21411 PyThreadState* __tstate = wxPyBeginAllowThreads();
21412 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21413
21414 wxPyEndAllowThreads(__tstate);
21415 if (PyErr_Occurred()) SWIG_fail;
21416 }
21417 {
21418 resultobj = SWIG_From_int((int)(result));
21419 }
21420 {
21421 if (temp2) delete arg2;
21422 }
21423 return resultobj;
21424 fail:
21425 {
21426 if (temp2) delete arg2;
21427 }
21428 return NULL;
21429 }
21430
21431
21432 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21433 PyObject *resultobj;
21434 wxDateTime *arg1 = (wxDateTime *) 0 ;
21435 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21436 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21437 wxDateTime::Month result;
21438 bool temp2 = false ;
21439 PyObject * obj0 = 0 ;
21440 PyObject * obj1 = 0 ;
21441 char *kwnames[] = {
21442 (char *) "self",(char *) "tz", NULL
21443 };
21444
21445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21447 if (SWIG_arg_fail(1)) SWIG_fail;
21448 if (obj1) {
21449 {
21450 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21451 temp2 = true;
21452 }
21453 }
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21457
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 resultobj = SWIG_From_int((result));
21462 {
21463 if (temp2) delete arg2;
21464 }
21465 return resultobj;
21466 fail:
21467 {
21468 if (temp2) delete arg2;
21469 }
21470 return NULL;
21471 }
21472
21473
21474 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21475 PyObject *resultobj;
21476 wxDateTime *arg1 = (wxDateTime *) 0 ;
21477 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21478 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21479 int result;
21480 bool temp2 = false ;
21481 PyObject * obj0 = 0 ;
21482 PyObject * obj1 = 0 ;
21483 char *kwnames[] = {
21484 (char *) "self",(char *) "tz", NULL
21485 };
21486
21487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21489 if (SWIG_arg_fail(1)) SWIG_fail;
21490 if (obj1) {
21491 {
21492 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21493 temp2 = true;
21494 }
21495 }
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 {
21504 resultobj = SWIG_From_int((int)(result));
21505 }
21506 {
21507 if (temp2) delete arg2;
21508 }
21509 return resultobj;
21510 fail:
21511 {
21512 if (temp2) delete arg2;
21513 }
21514 return NULL;
21515 }
21516
21517
21518 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21519 PyObject *resultobj;
21520 wxDateTime *arg1 = (wxDateTime *) 0 ;
21521 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21522 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21523 wxDateTime::WeekDay result;
21524 bool temp2 = false ;
21525 PyObject * obj0 = 0 ;
21526 PyObject * obj1 = 0 ;
21527 char *kwnames[] = {
21528 (char *) "self",(char *) "tz", NULL
21529 };
21530
21531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21533 if (SWIG_arg_fail(1)) SWIG_fail;
21534 if (obj1) {
21535 {
21536 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21537 temp2 = true;
21538 }
21539 }
21540 {
21541 PyThreadState* __tstate = wxPyBeginAllowThreads();
21542 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21543
21544 wxPyEndAllowThreads(__tstate);
21545 if (PyErr_Occurred()) SWIG_fail;
21546 }
21547 resultobj = SWIG_From_int((result));
21548 {
21549 if (temp2) delete arg2;
21550 }
21551 return resultobj;
21552 fail:
21553 {
21554 if (temp2) delete arg2;
21555 }
21556 return NULL;
21557 }
21558
21559
21560 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj;
21562 wxDateTime *arg1 = (wxDateTime *) 0 ;
21563 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21564 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21565 int result;
21566 bool temp2 = false ;
21567 PyObject * obj0 = 0 ;
21568 PyObject * obj1 = 0 ;
21569 char *kwnames[] = {
21570 (char *) "self",(char *) "tz", NULL
21571 };
21572
21573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21575 if (SWIG_arg_fail(1)) SWIG_fail;
21576 if (obj1) {
21577 {
21578 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21579 temp2 = true;
21580 }
21581 }
21582 {
21583 PyThreadState* __tstate = wxPyBeginAllowThreads();
21584 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21585
21586 wxPyEndAllowThreads(__tstate);
21587 if (PyErr_Occurred()) SWIG_fail;
21588 }
21589 {
21590 resultobj = SWIG_From_int((int)(result));
21591 }
21592 {
21593 if (temp2) delete arg2;
21594 }
21595 return resultobj;
21596 fail:
21597 {
21598 if (temp2) delete arg2;
21599 }
21600 return NULL;
21601 }
21602
21603
21604 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21605 PyObject *resultobj;
21606 wxDateTime *arg1 = (wxDateTime *) 0 ;
21607 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21608 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21609 int result;
21610 bool temp2 = false ;
21611 PyObject * obj0 = 0 ;
21612 PyObject * obj1 = 0 ;
21613 char *kwnames[] = {
21614 (char *) "self",(char *) "tz", NULL
21615 };
21616
21617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21619 if (SWIG_arg_fail(1)) SWIG_fail;
21620 if (obj1) {
21621 {
21622 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21623 temp2 = true;
21624 }
21625 }
21626 {
21627 PyThreadState* __tstate = wxPyBeginAllowThreads();
21628 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21629
21630 wxPyEndAllowThreads(__tstate);
21631 if (PyErr_Occurred()) SWIG_fail;
21632 }
21633 {
21634 resultobj = SWIG_From_int((int)(result));
21635 }
21636 {
21637 if (temp2) delete arg2;
21638 }
21639 return resultobj;
21640 fail:
21641 {
21642 if (temp2) delete arg2;
21643 }
21644 return NULL;
21645 }
21646
21647
21648 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21649 PyObject *resultobj;
21650 wxDateTime *arg1 = (wxDateTime *) 0 ;
21651 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21652 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21653 int result;
21654 bool temp2 = false ;
21655 PyObject * obj0 = 0 ;
21656 PyObject * obj1 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "self",(char *) "tz", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21663 if (SWIG_arg_fail(1)) SWIG_fail;
21664 if (obj1) {
21665 {
21666 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21667 temp2 = true;
21668 }
21669 }
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21673
21674 wxPyEndAllowThreads(__tstate);
21675 if (PyErr_Occurred()) SWIG_fail;
21676 }
21677 {
21678 resultobj = SWIG_From_int((int)(result));
21679 }
21680 {
21681 if (temp2) delete arg2;
21682 }
21683 return resultobj;
21684 fail:
21685 {
21686 if (temp2) delete arg2;
21687 }
21688 return NULL;
21689 }
21690
21691
21692 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21693 PyObject *resultobj;
21694 wxDateTime *arg1 = (wxDateTime *) 0 ;
21695 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21696 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21697 int result;
21698 bool temp2 = false ;
21699 PyObject * obj0 = 0 ;
21700 PyObject * obj1 = 0 ;
21701 char *kwnames[] = {
21702 (char *) "self",(char *) "tz", NULL
21703 };
21704
21705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21707 if (SWIG_arg_fail(1)) SWIG_fail;
21708 if (obj1) {
21709 {
21710 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21711 temp2 = true;
21712 }
21713 }
21714 {
21715 PyThreadState* __tstate = wxPyBeginAllowThreads();
21716 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21717
21718 wxPyEndAllowThreads(__tstate);
21719 if (PyErr_Occurred()) SWIG_fail;
21720 }
21721 {
21722 resultobj = SWIG_From_int((int)(result));
21723 }
21724 {
21725 if (temp2) delete arg2;
21726 }
21727 return resultobj;
21728 fail:
21729 {
21730 if (temp2) delete arg2;
21731 }
21732 return NULL;
21733 }
21734
21735
21736 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj;
21738 wxDateTime *arg1 = (wxDateTime *) 0 ;
21739 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21740 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21741 int result;
21742 bool temp2 = false ;
21743 PyObject * obj0 = 0 ;
21744 PyObject * obj1 = 0 ;
21745 char *kwnames[] = {
21746 (char *) "self",(char *) "tz", NULL
21747 };
21748
21749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21751 if (SWIG_arg_fail(1)) SWIG_fail;
21752 if (obj1) {
21753 {
21754 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21755 temp2 = true;
21756 }
21757 }
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21761
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 {
21766 resultobj = SWIG_From_int((int)(result));
21767 }
21768 {
21769 if (temp2) delete arg2;
21770 }
21771 return resultobj;
21772 fail:
21773 {
21774 if (temp2) delete arg2;
21775 }
21776 return NULL;
21777 }
21778
21779
21780 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21781 PyObject *resultobj;
21782 wxDateTime *arg1 = (wxDateTime *) 0 ;
21783 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21784 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21785 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21786 int result;
21787 bool temp3 = false ;
21788 PyObject * obj0 = 0 ;
21789 PyObject * obj1 = 0 ;
21790 PyObject * obj2 = 0 ;
21791 char *kwnames[] = {
21792 (char *) "self",(char *) "flags",(char *) "tz", NULL
21793 };
21794
21795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21797 if (SWIG_arg_fail(1)) SWIG_fail;
21798 if (obj1) {
21799 {
21800 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21801 if (SWIG_arg_fail(2)) SWIG_fail;
21802 }
21803 }
21804 if (obj2) {
21805 {
21806 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21807 temp3 = true;
21808 }
21809 }
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21813
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 {
21818 resultobj = SWIG_From_int((int)(result));
21819 }
21820 {
21821 if (temp3) delete arg3;
21822 }
21823 return resultobj;
21824 fail:
21825 {
21826 if (temp3) delete arg3;
21827 }
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxDateTime *arg1 = (wxDateTime *) 0 ;
21835 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21836 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21837 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21838 int result;
21839 bool temp3 = false ;
21840 PyObject * obj0 = 0 ;
21841 PyObject * obj1 = 0 ;
21842 PyObject * obj2 = 0 ;
21843 char *kwnames[] = {
21844 (char *) "self",(char *) "flags",(char *) "tz", NULL
21845 };
21846
21847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21849 if (SWIG_arg_fail(1)) SWIG_fail;
21850 if (obj1) {
21851 {
21852 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21853 if (SWIG_arg_fail(2)) SWIG_fail;
21854 }
21855 }
21856 if (obj2) {
21857 {
21858 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21859 temp3 = true;
21860 }
21861 }
21862 {
21863 PyThreadState* __tstate = wxPyBeginAllowThreads();
21864 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21865
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 {
21870 resultobj = SWIG_From_int((int)(result));
21871 }
21872 {
21873 if (temp3) delete arg3;
21874 }
21875 return resultobj;
21876 fail:
21877 {
21878 if (temp3) delete arg3;
21879 }
21880 return NULL;
21881 }
21882
21883
21884 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21885 PyObject *resultobj;
21886 wxDateTime *arg1 = (wxDateTime *) 0 ;
21887 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21888 bool result;
21889 PyObject * obj0 = 0 ;
21890 PyObject * obj1 = 0 ;
21891 char *kwnames[] = {
21892 (char *) "self",(char *) "country", NULL
21893 };
21894
21895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21897 if (SWIG_arg_fail(1)) SWIG_fail;
21898 if (obj1) {
21899 {
21900 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21901 if (SWIG_arg_fail(2)) SWIG_fail;
21902 }
21903 }
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21907
21908 wxPyEndAllowThreads(__tstate);
21909 if (PyErr_Occurred()) SWIG_fail;
21910 }
21911 {
21912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21913 }
21914 return resultobj;
21915 fail:
21916 return NULL;
21917 }
21918
21919
21920 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21921 PyObject *resultobj;
21922 wxDateTime *arg1 = (wxDateTime *) 0 ;
21923 wxDateTime *arg2 = 0 ;
21924 bool result;
21925 PyObject * obj0 = 0 ;
21926 PyObject * obj1 = 0 ;
21927 char *kwnames[] = {
21928 (char *) "self",(char *) "datetime", NULL
21929 };
21930
21931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21933 if (SWIG_arg_fail(1)) SWIG_fail;
21934 {
21935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21936 if (SWIG_arg_fail(2)) SWIG_fail;
21937 if (arg2 == NULL) {
21938 SWIG_null_ref("wxDateTime");
21939 }
21940 if (SWIG_arg_fail(2)) SWIG_fail;
21941 }
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21945
21946 wxPyEndAllowThreads(__tstate);
21947 if (PyErr_Occurred()) SWIG_fail;
21948 }
21949 {
21950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21951 }
21952 return resultobj;
21953 fail:
21954 return NULL;
21955 }
21956
21957
21958 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21959 PyObject *resultobj;
21960 wxDateTime *arg1 = (wxDateTime *) 0 ;
21961 wxDateTime *arg2 = 0 ;
21962 bool result;
21963 PyObject * obj0 = 0 ;
21964 PyObject * obj1 = 0 ;
21965 char *kwnames[] = {
21966 (char *) "self",(char *) "datetime", NULL
21967 };
21968
21969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21971 if (SWIG_arg_fail(1)) SWIG_fail;
21972 {
21973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21974 if (SWIG_arg_fail(2)) SWIG_fail;
21975 if (arg2 == NULL) {
21976 SWIG_null_ref("wxDateTime");
21977 }
21978 if (SWIG_arg_fail(2)) SWIG_fail;
21979 }
21980 {
21981 PyThreadState* __tstate = wxPyBeginAllowThreads();
21982 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21983
21984 wxPyEndAllowThreads(__tstate);
21985 if (PyErr_Occurred()) SWIG_fail;
21986 }
21987 {
21988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21989 }
21990 return resultobj;
21991 fail:
21992 return NULL;
21993 }
21994
21995
21996 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21997 PyObject *resultobj;
21998 wxDateTime *arg1 = (wxDateTime *) 0 ;
21999 wxDateTime *arg2 = 0 ;
22000 bool result;
22001 PyObject * obj0 = 0 ;
22002 PyObject * obj1 = 0 ;
22003 char *kwnames[] = {
22004 (char *) "self",(char *) "datetime", NULL
22005 };
22006
22007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22009 if (SWIG_arg_fail(1)) SWIG_fail;
22010 {
22011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22012 if (SWIG_arg_fail(2)) SWIG_fail;
22013 if (arg2 == NULL) {
22014 SWIG_null_ref("wxDateTime");
22015 }
22016 if (SWIG_arg_fail(2)) SWIG_fail;
22017 }
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22021
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 {
22026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22027 }
22028 return resultobj;
22029 fail:
22030 return NULL;
22031 }
22032
22033
22034 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22035 PyObject *resultobj;
22036 wxDateTime *arg1 = (wxDateTime *) 0 ;
22037 wxDateTime *arg2 = 0 ;
22038 wxDateTime *arg3 = 0 ;
22039 bool result;
22040 PyObject * obj0 = 0 ;
22041 PyObject * obj1 = 0 ;
22042 PyObject * obj2 = 0 ;
22043 char *kwnames[] = {
22044 (char *) "self",(char *) "t1",(char *) "t2", NULL
22045 };
22046
22047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22049 if (SWIG_arg_fail(1)) SWIG_fail;
22050 {
22051 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22052 if (SWIG_arg_fail(2)) SWIG_fail;
22053 if (arg2 == NULL) {
22054 SWIG_null_ref("wxDateTime");
22055 }
22056 if (SWIG_arg_fail(2)) SWIG_fail;
22057 }
22058 {
22059 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22060 if (SWIG_arg_fail(3)) SWIG_fail;
22061 if (arg3 == NULL) {
22062 SWIG_null_ref("wxDateTime");
22063 }
22064 if (SWIG_arg_fail(3)) SWIG_fail;
22065 }
22066 {
22067 PyThreadState* __tstate = wxPyBeginAllowThreads();
22068 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22069
22070 wxPyEndAllowThreads(__tstate);
22071 if (PyErr_Occurred()) SWIG_fail;
22072 }
22073 {
22074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22075 }
22076 return resultobj;
22077 fail:
22078 return NULL;
22079 }
22080
22081
22082 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22083 PyObject *resultobj;
22084 wxDateTime *arg1 = (wxDateTime *) 0 ;
22085 wxDateTime *arg2 = 0 ;
22086 wxDateTime *arg3 = 0 ;
22087 bool result;
22088 PyObject * obj0 = 0 ;
22089 PyObject * obj1 = 0 ;
22090 PyObject * obj2 = 0 ;
22091 char *kwnames[] = {
22092 (char *) "self",(char *) "t1",(char *) "t2", NULL
22093 };
22094
22095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22097 if (SWIG_arg_fail(1)) SWIG_fail;
22098 {
22099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22100 if (SWIG_arg_fail(2)) SWIG_fail;
22101 if (arg2 == NULL) {
22102 SWIG_null_ref("wxDateTime");
22103 }
22104 if (SWIG_arg_fail(2)) SWIG_fail;
22105 }
22106 {
22107 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22108 if (SWIG_arg_fail(3)) SWIG_fail;
22109 if (arg3 == NULL) {
22110 SWIG_null_ref("wxDateTime");
22111 }
22112 if (SWIG_arg_fail(3)) SWIG_fail;
22113 }
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22117
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 {
22122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22123 }
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22131 PyObject *resultobj;
22132 wxDateTime *arg1 = (wxDateTime *) 0 ;
22133 wxDateTime *arg2 = 0 ;
22134 bool result;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char *kwnames[] = {
22138 (char *) "self",(char *) "dt", NULL
22139 };
22140
22141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22143 if (SWIG_arg_fail(1)) SWIG_fail;
22144 {
22145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(2)) SWIG_fail;
22147 if (arg2 == NULL) {
22148 SWIG_null_ref("wxDateTime");
22149 }
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22155
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 {
22160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22161 }
22162 return resultobj;
22163 fail:
22164 return NULL;
22165 }
22166
22167
22168 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22169 PyObject *resultobj;
22170 wxDateTime *arg1 = (wxDateTime *) 0 ;
22171 wxDateTime *arg2 = 0 ;
22172 bool result;
22173 PyObject * obj0 = 0 ;
22174 PyObject * obj1 = 0 ;
22175 char *kwnames[] = {
22176 (char *) "self",(char *) "dt", NULL
22177 };
22178
22179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22181 if (SWIG_arg_fail(1)) SWIG_fail;
22182 {
22183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22184 if (SWIG_arg_fail(2)) SWIG_fail;
22185 if (arg2 == NULL) {
22186 SWIG_null_ref("wxDateTime");
22187 }
22188 if (SWIG_arg_fail(2)) SWIG_fail;
22189 }
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22193
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 {
22198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22199 }
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22207 PyObject *resultobj;
22208 wxDateTime *arg1 = (wxDateTime *) 0 ;
22209 wxDateTime *arg2 = 0 ;
22210 wxTimeSpan *arg3 = 0 ;
22211 bool result;
22212 PyObject * obj0 = 0 ;
22213 PyObject * obj1 = 0 ;
22214 PyObject * obj2 = 0 ;
22215 char *kwnames[] = {
22216 (char *) "self",(char *) "dt",(char *) "ts", NULL
22217 };
22218
22219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22221 if (SWIG_arg_fail(1)) SWIG_fail;
22222 {
22223 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22224 if (SWIG_arg_fail(2)) SWIG_fail;
22225 if (arg2 == NULL) {
22226 SWIG_null_ref("wxDateTime");
22227 }
22228 if (SWIG_arg_fail(2)) SWIG_fail;
22229 }
22230 {
22231 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22232 if (SWIG_arg_fail(3)) SWIG_fail;
22233 if (arg3 == NULL) {
22234 SWIG_null_ref("wxTimeSpan");
22235 }
22236 if (SWIG_arg_fail(3)) SWIG_fail;
22237 }
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22241
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 {
22246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22247 }
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22255 PyObject *resultobj;
22256 wxDateTime *arg1 = (wxDateTime *) 0 ;
22257 wxTimeSpan *arg2 = 0 ;
22258 wxDateTime *result;
22259 PyObject * obj0 = 0 ;
22260 PyObject * obj1 = 0 ;
22261 char *kwnames[] = {
22262 (char *) "self",(char *) "diff", NULL
22263 };
22264
22265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22267 if (SWIG_arg_fail(1)) SWIG_fail;
22268 {
22269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22270 if (SWIG_arg_fail(2)) SWIG_fail;
22271 if (arg2 == NULL) {
22272 SWIG_null_ref("wxTimeSpan");
22273 }
22274 if (SWIG_arg_fail(2)) SWIG_fail;
22275 }
22276 {
22277 PyThreadState* __tstate = wxPyBeginAllowThreads();
22278 {
22279 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22280 result = (wxDateTime *) &_result_ref;
22281 }
22282
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22294 PyObject *resultobj;
22295 wxDateTime *arg1 = (wxDateTime *) 0 ;
22296 wxDateSpan *arg2 = 0 ;
22297 wxDateTime *result;
22298 PyObject * obj0 = 0 ;
22299 PyObject * obj1 = 0 ;
22300 char *kwnames[] = {
22301 (char *) "self",(char *) "diff", NULL
22302 };
22303
22304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22306 if (SWIG_arg_fail(1)) SWIG_fail;
22307 {
22308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22309 if (SWIG_arg_fail(2)) SWIG_fail;
22310 if (arg2 == NULL) {
22311 SWIG_null_ref("wxDateSpan");
22312 }
22313 if (SWIG_arg_fail(2)) SWIG_fail;
22314 }
22315 {
22316 PyThreadState* __tstate = wxPyBeginAllowThreads();
22317 {
22318 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22319 result = (wxDateTime *) &_result_ref;
22320 }
22321
22322 wxPyEndAllowThreads(__tstate);
22323 if (PyErr_Occurred()) SWIG_fail;
22324 }
22325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22333 PyObject *resultobj;
22334 wxDateTime *arg1 = (wxDateTime *) 0 ;
22335 wxTimeSpan *arg2 = 0 ;
22336 wxDateTime *result;
22337 PyObject * obj0 = 0 ;
22338 PyObject * obj1 = 0 ;
22339 char *kwnames[] = {
22340 (char *) "self",(char *) "diff", NULL
22341 };
22342
22343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22345 if (SWIG_arg_fail(1)) SWIG_fail;
22346 {
22347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22348 if (SWIG_arg_fail(2)) SWIG_fail;
22349 if (arg2 == NULL) {
22350 SWIG_null_ref("wxTimeSpan");
22351 }
22352 if (SWIG_arg_fail(2)) SWIG_fail;
22353 }
22354 {
22355 PyThreadState* __tstate = wxPyBeginAllowThreads();
22356 {
22357 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22358 result = (wxDateTime *) &_result_ref;
22359 }
22360
22361 wxPyEndAllowThreads(__tstate);
22362 if (PyErr_Occurred()) SWIG_fail;
22363 }
22364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22365 return resultobj;
22366 fail:
22367 return NULL;
22368 }
22369
22370
22371 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22372 PyObject *resultobj;
22373 wxDateTime *arg1 = (wxDateTime *) 0 ;
22374 wxDateSpan *arg2 = 0 ;
22375 wxDateTime *result;
22376 PyObject * obj0 = 0 ;
22377 PyObject * obj1 = 0 ;
22378 char *kwnames[] = {
22379 (char *) "self",(char *) "diff", NULL
22380 };
22381
22382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22384 if (SWIG_arg_fail(1)) SWIG_fail;
22385 {
22386 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22387 if (SWIG_arg_fail(2)) SWIG_fail;
22388 if (arg2 == NULL) {
22389 SWIG_null_ref("wxDateSpan");
22390 }
22391 if (SWIG_arg_fail(2)) SWIG_fail;
22392 }
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 {
22396 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22397 result = (wxDateTime *) &_result_ref;
22398 }
22399
22400 wxPyEndAllowThreads(__tstate);
22401 if (PyErr_Occurred()) SWIG_fail;
22402 }
22403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj;
22412 wxDateTime *arg1 = (wxDateTime *) 0 ;
22413 wxDateTime *arg2 = 0 ;
22414 wxTimeSpan result;
22415 PyObject * obj0 = 0 ;
22416 PyObject * obj1 = 0 ;
22417 char *kwnames[] = {
22418 (char *) "self",(char *) "dt", NULL
22419 };
22420
22421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22423 if (SWIG_arg_fail(1)) SWIG_fail;
22424 {
22425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22426 if (SWIG_arg_fail(2)) SWIG_fail;
22427 if (arg2 == NULL) {
22428 SWIG_null_ref("wxDateTime");
22429 }
22430 if (SWIG_arg_fail(2)) SWIG_fail;
22431 }
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22435
22436 wxPyEndAllowThreads(__tstate);
22437 if (PyErr_Occurred()) SWIG_fail;
22438 }
22439 {
22440 wxTimeSpan * resultptr;
22441 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22443 }
22444 return resultobj;
22445 fail:
22446 return NULL;
22447 }
22448
22449
22450 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22451 PyObject *resultobj;
22452 wxDateTime *arg1 = (wxDateTime *) 0 ;
22453 wxTimeSpan *arg2 = 0 ;
22454 wxDateTime *result;
22455 PyObject * obj0 = 0 ;
22456 PyObject * obj1 = 0 ;
22457
22458 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22460 if (SWIG_arg_fail(1)) SWIG_fail;
22461 {
22462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22463 if (SWIG_arg_fail(2)) SWIG_fail;
22464 if (arg2 == NULL) {
22465 SWIG_null_ref("wxTimeSpan");
22466 }
22467 if (SWIG_arg_fail(2)) SWIG_fail;
22468 }
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 {
22472 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22473 result = (wxDateTime *) &_result_ref;
22474 }
22475
22476 wxPyEndAllowThreads(__tstate);
22477 if (PyErr_Occurred()) SWIG_fail;
22478 }
22479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22487 PyObject *resultobj;
22488 wxDateTime *arg1 = (wxDateTime *) 0 ;
22489 wxDateSpan *arg2 = 0 ;
22490 wxDateTime *result;
22491 PyObject * obj0 = 0 ;
22492 PyObject * obj1 = 0 ;
22493
22494 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22496 if (SWIG_arg_fail(1)) SWIG_fail;
22497 {
22498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22499 if (SWIG_arg_fail(2)) SWIG_fail;
22500 if (arg2 == NULL) {
22501 SWIG_null_ref("wxDateSpan");
22502 }
22503 if (SWIG_arg_fail(2)) SWIG_fail;
22504 }
22505 {
22506 PyThreadState* __tstate = wxPyBeginAllowThreads();
22507 {
22508 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22509 result = (wxDateTime *) &_result_ref;
22510 }
22511
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22523 int argc;
22524 PyObject *argv[3];
22525 int ii;
22526
22527 argc = PyObject_Length(args);
22528 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22529 argv[ii] = PyTuple_GetItem(args,ii);
22530 }
22531 if (argc == 2) {
22532 int _v;
22533 {
22534 void *ptr;
22535 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22536 _v = 0;
22537 PyErr_Clear();
22538 } else {
22539 _v = 1;
22540 }
22541 }
22542 if (_v) {
22543 {
22544 void *ptr = 0;
22545 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22546 _v = 0;
22547 PyErr_Clear();
22548 } else {
22549 _v = (ptr != 0);
22550 }
22551 }
22552 if (_v) {
22553 return _wrap_DateTime___iadd____SWIG_0(self,args);
22554 }
22555 }
22556 }
22557 if (argc == 2) {
22558 int _v;
22559 {
22560 void *ptr;
22561 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22562 _v = 0;
22563 PyErr_Clear();
22564 } else {
22565 _v = 1;
22566 }
22567 }
22568 if (_v) {
22569 {
22570 void *ptr = 0;
22571 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22572 _v = 0;
22573 PyErr_Clear();
22574 } else {
22575 _v = (ptr != 0);
22576 }
22577 }
22578 if (_v) {
22579 return _wrap_DateTime___iadd____SWIG_1(self,args);
22580 }
22581 }
22582 }
22583
22584 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22585 return NULL;
22586 }
22587
22588
22589 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22590 PyObject *resultobj;
22591 wxDateTime *arg1 = (wxDateTime *) 0 ;
22592 wxTimeSpan *arg2 = 0 ;
22593 wxDateTime *result;
22594 PyObject * obj0 = 0 ;
22595 PyObject * obj1 = 0 ;
22596
22597 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22599 if (SWIG_arg_fail(1)) SWIG_fail;
22600 {
22601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22602 if (SWIG_arg_fail(2)) SWIG_fail;
22603 if (arg2 == NULL) {
22604 SWIG_null_ref("wxTimeSpan");
22605 }
22606 if (SWIG_arg_fail(2)) SWIG_fail;
22607 }
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 {
22611 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22612 result = (wxDateTime *) &_result_ref;
22613 }
22614
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22626 PyObject *resultobj;
22627 wxDateTime *arg1 = (wxDateTime *) 0 ;
22628 wxDateSpan *arg2 = 0 ;
22629 wxDateTime *result;
22630 PyObject * obj0 = 0 ;
22631 PyObject * obj1 = 0 ;
22632
22633 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22635 if (SWIG_arg_fail(1)) SWIG_fail;
22636 {
22637 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22638 if (SWIG_arg_fail(2)) SWIG_fail;
22639 if (arg2 == NULL) {
22640 SWIG_null_ref("wxDateSpan");
22641 }
22642 if (SWIG_arg_fail(2)) SWIG_fail;
22643 }
22644 {
22645 PyThreadState* __tstate = wxPyBeginAllowThreads();
22646 {
22647 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22648 result = (wxDateTime *) &_result_ref;
22649 }
22650
22651 wxPyEndAllowThreads(__tstate);
22652 if (PyErr_Occurred()) SWIG_fail;
22653 }
22654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22655 return resultobj;
22656 fail:
22657 return NULL;
22658 }
22659
22660
22661 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22662 int argc;
22663 PyObject *argv[3];
22664 int ii;
22665
22666 argc = PyObject_Length(args);
22667 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22668 argv[ii] = PyTuple_GetItem(args,ii);
22669 }
22670 if (argc == 2) {
22671 int _v;
22672 {
22673 void *ptr;
22674 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22675 _v = 0;
22676 PyErr_Clear();
22677 } else {
22678 _v = 1;
22679 }
22680 }
22681 if (_v) {
22682 {
22683 void *ptr = 0;
22684 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22685 _v = 0;
22686 PyErr_Clear();
22687 } else {
22688 _v = (ptr != 0);
22689 }
22690 }
22691 if (_v) {
22692 return _wrap_DateTime___isub____SWIG_0(self,args);
22693 }
22694 }
22695 }
22696 if (argc == 2) {
22697 int _v;
22698 {
22699 void *ptr;
22700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22701 _v = 0;
22702 PyErr_Clear();
22703 } else {
22704 _v = 1;
22705 }
22706 }
22707 if (_v) {
22708 {
22709 void *ptr = 0;
22710 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22711 _v = 0;
22712 PyErr_Clear();
22713 } else {
22714 _v = (ptr != 0);
22715 }
22716 }
22717 if (_v) {
22718 return _wrap_DateTime___isub____SWIG_1(self,args);
22719 }
22720 }
22721 }
22722
22723 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22724 return NULL;
22725 }
22726
22727
22728 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22729 PyObject *resultobj;
22730 wxDateTime *arg1 = (wxDateTime *) 0 ;
22731 wxTimeSpan *arg2 = 0 ;
22732 wxDateTime result;
22733 PyObject * obj0 = 0 ;
22734 PyObject * obj1 = 0 ;
22735
22736 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22738 if (SWIG_arg_fail(1)) SWIG_fail;
22739 {
22740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22741 if (SWIG_arg_fail(2)) SWIG_fail;
22742 if (arg2 == NULL) {
22743 SWIG_null_ref("wxTimeSpan");
22744 }
22745 if (SWIG_arg_fail(2)) SWIG_fail;
22746 }
22747 {
22748 PyThreadState* __tstate = wxPyBeginAllowThreads();
22749 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22750
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 {
22755 wxDateTime * resultptr;
22756 resultptr = new wxDateTime((wxDateTime &)(result));
22757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22758 }
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22766 PyObject *resultobj;
22767 wxDateTime *arg1 = (wxDateTime *) 0 ;
22768 wxDateSpan *arg2 = 0 ;
22769 wxDateTime result;
22770 PyObject * obj0 = 0 ;
22771 PyObject * obj1 = 0 ;
22772
22773 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22775 if (SWIG_arg_fail(1)) SWIG_fail;
22776 {
22777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22778 if (SWIG_arg_fail(2)) SWIG_fail;
22779 if (arg2 == NULL) {
22780 SWIG_null_ref("wxDateSpan");
22781 }
22782 if (SWIG_arg_fail(2)) SWIG_fail;
22783 }
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22787
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 {
22792 wxDateTime * resultptr;
22793 resultptr = new wxDateTime((wxDateTime &)(result));
22794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22795 }
22796 return resultobj;
22797 fail:
22798 return NULL;
22799 }
22800
22801
22802 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22803 int argc;
22804 PyObject *argv[3];
22805 int ii;
22806
22807 argc = PyObject_Length(args);
22808 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22809 argv[ii] = PyTuple_GetItem(args,ii);
22810 }
22811 if (argc == 2) {
22812 int _v;
22813 {
22814 void *ptr;
22815 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22816 _v = 0;
22817 PyErr_Clear();
22818 } else {
22819 _v = 1;
22820 }
22821 }
22822 if (_v) {
22823 {
22824 void *ptr = 0;
22825 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22826 _v = 0;
22827 PyErr_Clear();
22828 } else {
22829 _v = (ptr != 0);
22830 }
22831 }
22832 if (_v) {
22833 return _wrap_DateTime___add____SWIG_0(self,args);
22834 }
22835 }
22836 }
22837 if (argc == 2) {
22838 int _v;
22839 {
22840 void *ptr;
22841 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22842 _v = 0;
22843 PyErr_Clear();
22844 } else {
22845 _v = 1;
22846 }
22847 }
22848 if (_v) {
22849 {
22850 void *ptr = 0;
22851 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22852 _v = 0;
22853 PyErr_Clear();
22854 } else {
22855 _v = (ptr != 0);
22856 }
22857 }
22858 if (_v) {
22859 return _wrap_DateTime___add____SWIG_1(self,args);
22860 }
22861 }
22862 }
22863
22864 Py_INCREF(Py_NotImplemented);
22865 return Py_NotImplemented;
22866 }
22867
22868
22869 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22870 PyObject *resultobj;
22871 wxDateTime *arg1 = (wxDateTime *) 0 ;
22872 wxDateTime *arg2 = 0 ;
22873 wxTimeSpan result;
22874 PyObject * obj0 = 0 ;
22875 PyObject * obj1 = 0 ;
22876
22877 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22879 if (SWIG_arg_fail(1)) SWIG_fail;
22880 {
22881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22882 if (SWIG_arg_fail(2)) SWIG_fail;
22883 if (arg2 == NULL) {
22884 SWIG_null_ref("wxDateTime");
22885 }
22886 if (SWIG_arg_fail(2)) SWIG_fail;
22887 }
22888 {
22889 PyThreadState* __tstate = wxPyBeginAllowThreads();
22890 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22891
22892 wxPyEndAllowThreads(__tstate);
22893 if (PyErr_Occurred()) SWIG_fail;
22894 }
22895 {
22896 wxTimeSpan * resultptr;
22897 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22899 }
22900 return resultobj;
22901 fail:
22902 return NULL;
22903 }
22904
22905
22906 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22907 PyObject *resultobj;
22908 wxDateTime *arg1 = (wxDateTime *) 0 ;
22909 wxTimeSpan *arg2 = 0 ;
22910 wxDateTime result;
22911 PyObject * obj0 = 0 ;
22912 PyObject * obj1 = 0 ;
22913
22914 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22916 if (SWIG_arg_fail(1)) SWIG_fail;
22917 {
22918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22919 if (SWIG_arg_fail(2)) SWIG_fail;
22920 if (arg2 == NULL) {
22921 SWIG_null_ref("wxTimeSpan");
22922 }
22923 if (SWIG_arg_fail(2)) SWIG_fail;
22924 }
22925 {
22926 PyThreadState* __tstate = wxPyBeginAllowThreads();
22927 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22928
22929 wxPyEndAllowThreads(__tstate);
22930 if (PyErr_Occurred()) SWIG_fail;
22931 }
22932 {
22933 wxDateTime * resultptr;
22934 resultptr = new wxDateTime((wxDateTime &)(result));
22935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22936 }
22937 return resultobj;
22938 fail:
22939 return NULL;
22940 }
22941
22942
22943 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22944 PyObject *resultobj;
22945 wxDateTime *arg1 = (wxDateTime *) 0 ;
22946 wxDateSpan *arg2 = 0 ;
22947 wxDateTime result;
22948 PyObject * obj0 = 0 ;
22949 PyObject * obj1 = 0 ;
22950
22951 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22953 if (SWIG_arg_fail(1)) SWIG_fail;
22954 {
22955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22956 if (SWIG_arg_fail(2)) SWIG_fail;
22957 if (arg2 == NULL) {
22958 SWIG_null_ref("wxDateSpan");
22959 }
22960 if (SWIG_arg_fail(2)) SWIG_fail;
22961 }
22962 {
22963 PyThreadState* __tstate = wxPyBeginAllowThreads();
22964 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22965
22966 wxPyEndAllowThreads(__tstate);
22967 if (PyErr_Occurred()) SWIG_fail;
22968 }
22969 {
22970 wxDateTime * resultptr;
22971 resultptr = new wxDateTime((wxDateTime &)(result));
22972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22973 }
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22981 int argc;
22982 PyObject *argv[3];
22983 int ii;
22984
22985 argc = PyObject_Length(args);
22986 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22987 argv[ii] = PyTuple_GetItem(args,ii);
22988 }
22989 if (argc == 2) {
22990 int _v;
22991 {
22992 void *ptr;
22993 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22994 _v = 0;
22995 PyErr_Clear();
22996 } else {
22997 _v = 1;
22998 }
22999 }
23000 if (_v) {
23001 {
23002 void *ptr = 0;
23003 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23004 _v = 0;
23005 PyErr_Clear();
23006 } else {
23007 _v = (ptr != 0);
23008 }
23009 }
23010 if (_v) {
23011 return _wrap_DateTime___sub____SWIG_0(self,args);
23012 }
23013 }
23014 }
23015 if (argc == 2) {
23016 int _v;
23017 {
23018 void *ptr;
23019 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23020 _v = 0;
23021 PyErr_Clear();
23022 } else {
23023 _v = 1;
23024 }
23025 }
23026 if (_v) {
23027 {
23028 void *ptr = 0;
23029 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23030 _v = 0;
23031 PyErr_Clear();
23032 } else {
23033 _v = (ptr != 0);
23034 }
23035 }
23036 if (_v) {
23037 return _wrap_DateTime___sub____SWIG_1(self,args);
23038 }
23039 }
23040 }
23041 if (argc == 2) {
23042 int _v;
23043 {
23044 void *ptr;
23045 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23046 _v = 0;
23047 PyErr_Clear();
23048 } else {
23049 _v = 1;
23050 }
23051 }
23052 if (_v) {
23053 {
23054 void *ptr = 0;
23055 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23056 _v = 0;
23057 PyErr_Clear();
23058 } else {
23059 _v = (ptr != 0);
23060 }
23061 }
23062 if (_v) {
23063 return _wrap_DateTime___sub____SWIG_2(self,args);
23064 }
23065 }
23066 }
23067
23068 Py_INCREF(Py_NotImplemented);
23069 return Py_NotImplemented;
23070 }
23071
23072
23073 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23074 PyObject *resultobj;
23075 wxDateTime *arg1 = (wxDateTime *) 0 ;
23076 wxDateTime *arg2 = (wxDateTime *) 0 ;
23077 bool result;
23078 PyObject * obj0 = 0 ;
23079 PyObject * obj1 = 0 ;
23080 char *kwnames[] = {
23081 (char *) "self",(char *) "other", NULL
23082 };
23083
23084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23086 if (SWIG_arg_fail(1)) SWIG_fail;
23087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23088 if (SWIG_arg_fail(2)) SWIG_fail;
23089 {
23090 PyThreadState* __tstate = wxPyBeginAllowThreads();
23091 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23092
23093 wxPyEndAllowThreads(__tstate);
23094 if (PyErr_Occurred()) SWIG_fail;
23095 }
23096 {
23097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23098 }
23099 return resultobj;
23100 fail:
23101 return NULL;
23102 }
23103
23104
23105 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23106 PyObject *resultobj;
23107 wxDateTime *arg1 = (wxDateTime *) 0 ;
23108 wxDateTime *arg2 = (wxDateTime *) 0 ;
23109 bool result;
23110 PyObject * obj0 = 0 ;
23111 PyObject * obj1 = 0 ;
23112 char *kwnames[] = {
23113 (char *) "self",(char *) "other", NULL
23114 };
23115
23116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23118 if (SWIG_arg_fail(1)) SWIG_fail;
23119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23120 if (SWIG_arg_fail(2)) SWIG_fail;
23121 {
23122 PyThreadState* __tstate = wxPyBeginAllowThreads();
23123 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23124
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 {
23129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23130 }
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj;
23139 wxDateTime *arg1 = (wxDateTime *) 0 ;
23140 wxDateTime *arg2 = (wxDateTime *) 0 ;
23141 bool result;
23142 PyObject * obj0 = 0 ;
23143 PyObject * obj1 = 0 ;
23144 char *kwnames[] = {
23145 (char *) "self",(char *) "other", NULL
23146 };
23147
23148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23150 if (SWIG_arg_fail(1)) SWIG_fail;
23151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23152 if (SWIG_arg_fail(2)) SWIG_fail;
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23156
23157 wxPyEndAllowThreads(__tstate);
23158 if (PyErr_Occurred()) SWIG_fail;
23159 }
23160 {
23161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23162 }
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23170 PyObject *resultobj;
23171 wxDateTime *arg1 = (wxDateTime *) 0 ;
23172 wxDateTime *arg2 = (wxDateTime *) 0 ;
23173 bool result;
23174 PyObject * obj0 = 0 ;
23175 PyObject * obj1 = 0 ;
23176 char *kwnames[] = {
23177 (char *) "self",(char *) "other", NULL
23178 };
23179
23180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23182 if (SWIG_arg_fail(1)) SWIG_fail;
23183 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23184 if (SWIG_arg_fail(2)) SWIG_fail;
23185 {
23186 PyThreadState* __tstate = wxPyBeginAllowThreads();
23187 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23188
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 {
23193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23194 }
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23202 PyObject *resultobj;
23203 wxDateTime *arg1 = (wxDateTime *) 0 ;
23204 wxDateTime *arg2 = (wxDateTime *) 0 ;
23205 bool result;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char *kwnames[] = {
23209 (char *) "self",(char *) "other", NULL
23210 };
23211
23212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23214 if (SWIG_arg_fail(1)) SWIG_fail;
23215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23216 if (SWIG_arg_fail(2)) SWIG_fail;
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23220
23221 wxPyEndAllowThreads(__tstate);
23222 if (PyErr_Occurred()) SWIG_fail;
23223 }
23224 {
23225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23226 }
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj;
23235 wxDateTime *arg1 = (wxDateTime *) 0 ;
23236 wxDateTime *arg2 = (wxDateTime *) 0 ;
23237 bool result;
23238 PyObject * obj0 = 0 ;
23239 PyObject * obj1 = 0 ;
23240 char *kwnames[] = {
23241 (char *) "self",(char *) "other", NULL
23242 };
23243
23244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23246 if (SWIG_arg_fail(1)) SWIG_fail;
23247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23248 if (SWIG_arg_fail(2)) SWIG_fail;
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23252
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 {
23257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23258 }
23259 return resultobj;
23260 fail:
23261 return NULL;
23262 }
23263
23264
23265 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23266 PyObject *resultobj;
23267 wxDateTime *arg1 = (wxDateTime *) 0 ;
23268 wxString *arg2 = 0 ;
23269 int result;
23270 bool temp2 = false ;
23271 PyObject * obj0 = 0 ;
23272 PyObject * obj1 = 0 ;
23273 char *kwnames[] = {
23274 (char *) "self",(char *) "date", NULL
23275 };
23276
23277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23279 if (SWIG_arg_fail(1)) SWIG_fail;
23280 {
23281 arg2 = wxString_in_helper(obj1);
23282 if (arg2 == NULL) SWIG_fail;
23283 temp2 = true;
23284 }
23285 {
23286 PyThreadState* __tstate = wxPyBeginAllowThreads();
23287 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23288
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 {
23293 resultobj = SWIG_From_int((int)(result));
23294 }
23295 {
23296 if (temp2)
23297 delete arg2;
23298 }
23299 return resultobj;
23300 fail:
23301 {
23302 if (temp2)
23303 delete arg2;
23304 }
23305 return NULL;
23306 }
23307
23308
23309 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23310 PyObject *resultobj;
23311 wxDateTime *arg1 = (wxDateTime *) 0 ;
23312 wxString *arg2 = 0 ;
23313 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23314 wxString *arg3 = (wxString *) &arg3_defvalue ;
23315 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23316 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23317 int result;
23318 bool temp2 = false ;
23319 bool temp3 = false ;
23320 PyObject * obj0 = 0 ;
23321 PyObject * obj1 = 0 ;
23322 PyObject * obj2 = 0 ;
23323 PyObject * obj3 = 0 ;
23324 char *kwnames[] = {
23325 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23326 };
23327
23328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 if (obj2) {
23337 {
23338 arg3 = wxString_in_helper(obj2);
23339 if (arg3 == NULL) SWIG_fail;
23340 temp3 = true;
23341 }
23342 }
23343 if (obj3) {
23344 {
23345 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23346 if (SWIG_arg_fail(4)) SWIG_fail;
23347 if (arg4 == NULL) {
23348 SWIG_null_ref("wxDateTime");
23349 }
23350 if (SWIG_arg_fail(4)) SWIG_fail;
23351 }
23352 }
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23356
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 {
23361 resultobj = SWIG_From_int((int)(result));
23362 }
23363 {
23364 if (temp2)
23365 delete arg2;
23366 }
23367 {
23368 if (temp3)
23369 delete arg3;
23370 }
23371 return resultobj;
23372 fail:
23373 {
23374 if (temp2)
23375 delete arg2;
23376 }
23377 {
23378 if (temp3)
23379 delete arg3;
23380 }
23381 return NULL;
23382 }
23383
23384
23385 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23386 PyObject *resultobj;
23387 wxDateTime *arg1 = (wxDateTime *) 0 ;
23388 wxString *arg2 = 0 ;
23389 int result;
23390 bool temp2 = false ;
23391 PyObject * obj0 = 0 ;
23392 PyObject * obj1 = 0 ;
23393 char *kwnames[] = {
23394 (char *) "self",(char *) "datetime", NULL
23395 };
23396
23397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23399 if (SWIG_arg_fail(1)) SWIG_fail;
23400 {
23401 arg2 = wxString_in_helper(obj1);
23402 if (arg2 == NULL) SWIG_fail;
23403 temp2 = true;
23404 }
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23408
23409 wxPyEndAllowThreads(__tstate);
23410 if (PyErr_Occurred()) SWIG_fail;
23411 }
23412 {
23413 resultobj = SWIG_From_int((int)(result));
23414 }
23415 {
23416 if (temp2)
23417 delete arg2;
23418 }
23419 return resultobj;
23420 fail:
23421 {
23422 if (temp2)
23423 delete arg2;
23424 }
23425 return NULL;
23426 }
23427
23428
23429 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23430 PyObject *resultobj;
23431 wxDateTime *arg1 = (wxDateTime *) 0 ;
23432 wxString *arg2 = 0 ;
23433 int result;
23434 bool temp2 = false ;
23435 PyObject * obj0 = 0 ;
23436 PyObject * obj1 = 0 ;
23437 char *kwnames[] = {
23438 (char *) "self",(char *) "date", NULL
23439 };
23440
23441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23443 if (SWIG_arg_fail(1)) SWIG_fail;
23444 {
23445 arg2 = wxString_in_helper(obj1);
23446 if (arg2 == NULL) SWIG_fail;
23447 temp2 = true;
23448 }
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23452
23453 wxPyEndAllowThreads(__tstate);
23454 if (PyErr_Occurred()) SWIG_fail;
23455 }
23456 {
23457 resultobj = SWIG_From_int((int)(result));
23458 }
23459 {
23460 if (temp2)
23461 delete arg2;
23462 }
23463 return resultobj;
23464 fail:
23465 {
23466 if (temp2)
23467 delete arg2;
23468 }
23469 return NULL;
23470 }
23471
23472
23473 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj;
23475 wxDateTime *arg1 = (wxDateTime *) 0 ;
23476 wxString *arg2 = 0 ;
23477 int result;
23478 bool temp2 = false ;
23479 PyObject * obj0 = 0 ;
23480 PyObject * obj1 = 0 ;
23481 char *kwnames[] = {
23482 (char *) "self",(char *) "time", NULL
23483 };
23484
23485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23487 if (SWIG_arg_fail(1)) SWIG_fail;
23488 {
23489 arg2 = wxString_in_helper(obj1);
23490 if (arg2 == NULL) SWIG_fail;
23491 temp2 = true;
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23496
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 {
23501 resultobj = SWIG_From_int((int)(result));
23502 }
23503 {
23504 if (temp2)
23505 delete arg2;
23506 }
23507 return resultobj;
23508 fail:
23509 {
23510 if (temp2)
23511 delete arg2;
23512 }
23513 return NULL;
23514 }
23515
23516
23517 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23518 PyObject *resultobj;
23519 wxDateTime *arg1 = (wxDateTime *) 0 ;
23520 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23521 wxString *arg2 = (wxString *) &arg2_defvalue ;
23522 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23523 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23524 wxString result;
23525 bool temp2 = false ;
23526 bool temp3 = false ;
23527 PyObject * obj0 = 0 ;
23528 PyObject * obj1 = 0 ;
23529 PyObject * obj2 = 0 ;
23530 char *kwnames[] = {
23531 (char *) "self",(char *) "format",(char *) "tz", NULL
23532 };
23533
23534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23536 if (SWIG_arg_fail(1)) SWIG_fail;
23537 if (obj1) {
23538 {
23539 arg2 = wxString_in_helper(obj1);
23540 if (arg2 == NULL) SWIG_fail;
23541 temp2 = true;
23542 }
23543 }
23544 if (obj2) {
23545 {
23546 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23547 temp3 = true;
23548 }
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23553
23554 wxPyEndAllowThreads(__tstate);
23555 if (PyErr_Occurred()) SWIG_fail;
23556 }
23557 {
23558 #if wxUSE_UNICODE
23559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23560 #else
23561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23562 #endif
23563 }
23564 {
23565 if (temp2)
23566 delete arg2;
23567 }
23568 {
23569 if (temp3) delete arg3;
23570 }
23571 return resultobj;
23572 fail:
23573 {
23574 if (temp2)
23575 delete arg2;
23576 }
23577 {
23578 if (temp3) delete arg3;
23579 }
23580 return NULL;
23581 }
23582
23583
23584 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23585 PyObject *resultobj;
23586 wxDateTime *arg1 = (wxDateTime *) 0 ;
23587 wxString result;
23588 PyObject * obj0 = 0 ;
23589 char *kwnames[] = {
23590 (char *) "self", NULL
23591 };
23592
23593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23595 if (SWIG_arg_fail(1)) SWIG_fail;
23596 {
23597 PyThreadState* __tstate = wxPyBeginAllowThreads();
23598 result = ((wxDateTime const *)arg1)->FormatDate();
23599
23600 wxPyEndAllowThreads(__tstate);
23601 if (PyErr_Occurred()) SWIG_fail;
23602 }
23603 {
23604 #if wxUSE_UNICODE
23605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23606 #else
23607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23608 #endif
23609 }
23610 return resultobj;
23611 fail:
23612 return NULL;
23613 }
23614
23615
23616 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23617 PyObject *resultobj;
23618 wxDateTime *arg1 = (wxDateTime *) 0 ;
23619 wxString result;
23620 PyObject * obj0 = 0 ;
23621 char *kwnames[] = {
23622 (char *) "self", NULL
23623 };
23624
23625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23627 if (SWIG_arg_fail(1)) SWIG_fail;
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 result = ((wxDateTime const *)arg1)->FormatTime();
23631
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 {
23636 #if wxUSE_UNICODE
23637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23638 #else
23639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23640 #endif
23641 }
23642 return resultobj;
23643 fail:
23644 return NULL;
23645 }
23646
23647
23648 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23649 PyObject *resultobj;
23650 wxDateTime *arg1 = (wxDateTime *) 0 ;
23651 wxString result;
23652 PyObject * obj0 = 0 ;
23653 char *kwnames[] = {
23654 (char *) "self", NULL
23655 };
23656
23657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23659 if (SWIG_arg_fail(1)) SWIG_fail;
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = ((wxDateTime const *)arg1)->FormatISODate();
23663
23664 wxPyEndAllowThreads(__tstate);
23665 if (PyErr_Occurred()) SWIG_fail;
23666 }
23667 {
23668 #if wxUSE_UNICODE
23669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23670 #else
23671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23672 #endif
23673 }
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23681 PyObject *resultobj;
23682 wxDateTime *arg1 = (wxDateTime *) 0 ;
23683 wxString result;
23684 PyObject * obj0 = 0 ;
23685 char *kwnames[] = {
23686 (char *) "self", NULL
23687 };
23688
23689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23691 if (SWIG_arg_fail(1)) SWIG_fail;
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = ((wxDateTime const *)arg1)->FormatISOTime();
23695
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 #if wxUSE_UNICODE
23701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23702 #else
23703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23704 #endif
23705 }
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23713 PyObject *obj;
23714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23715 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23716 Py_INCREF(obj);
23717 return Py_BuildValue((char *)"");
23718 }
23719 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj;
23721 long arg1 ;
23722 wxTimeSpan result;
23723 PyObject * obj0 = 0 ;
23724 char *kwnames[] = {
23725 (char *) "sec", NULL
23726 };
23727
23728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23729 {
23730 arg1 = (long)(SWIG_As_long(obj0));
23731 if (SWIG_arg_fail(1)) SWIG_fail;
23732 }
23733 {
23734 PyThreadState* __tstate = wxPyBeginAllowThreads();
23735 result = wxTimeSpan::Seconds(arg1);
23736
23737 wxPyEndAllowThreads(__tstate);
23738 if (PyErr_Occurred()) SWIG_fail;
23739 }
23740 {
23741 wxTimeSpan * resultptr;
23742 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23744 }
23745 return resultobj;
23746 fail:
23747 return NULL;
23748 }
23749
23750
23751 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23752 PyObject *resultobj;
23753 wxTimeSpan result;
23754 char *kwnames[] = {
23755 NULL
23756 };
23757
23758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23759 {
23760 PyThreadState* __tstate = wxPyBeginAllowThreads();
23761 result = wxTimeSpan::Second();
23762
23763 wxPyEndAllowThreads(__tstate);
23764 if (PyErr_Occurred()) SWIG_fail;
23765 }
23766 {
23767 wxTimeSpan * resultptr;
23768 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23770 }
23771 return resultobj;
23772 fail:
23773 return NULL;
23774 }
23775
23776
23777 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23778 PyObject *resultobj;
23779 long arg1 ;
23780 wxTimeSpan result;
23781 PyObject * obj0 = 0 ;
23782 char *kwnames[] = {
23783 (char *) "min", NULL
23784 };
23785
23786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23787 {
23788 arg1 = (long)(SWIG_As_long(obj0));
23789 if (SWIG_arg_fail(1)) SWIG_fail;
23790 }
23791 {
23792 PyThreadState* __tstate = wxPyBeginAllowThreads();
23793 result = wxTimeSpan::Minutes(arg1);
23794
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 {
23799 wxTimeSpan * resultptr;
23800 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj;
23811 wxTimeSpan result;
23812 char *kwnames[] = {
23813 NULL
23814 };
23815
23816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23817 {
23818 PyThreadState* __tstate = wxPyBeginAllowThreads();
23819 result = wxTimeSpan::Minute();
23820
23821 wxPyEndAllowThreads(__tstate);
23822 if (PyErr_Occurred()) SWIG_fail;
23823 }
23824 {
23825 wxTimeSpan * resultptr;
23826 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23828 }
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23836 PyObject *resultobj;
23837 long arg1 ;
23838 wxTimeSpan result;
23839 PyObject * obj0 = 0 ;
23840 char *kwnames[] = {
23841 (char *) "hours", NULL
23842 };
23843
23844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23845 {
23846 arg1 = (long)(SWIG_As_long(obj0));
23847 if (SWIG_arg_fail(1)) SWIG_fail;
23848 }
23849 {
23850 PyThreadState* __tstate = wxPyBeginAllowThreads();
23851 result = wxTimeSpan::Hours(arg1);
23852
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 {
23857 wxTimeSpan * resultptr;
23858 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23860 }
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23868 PyObject *resultobj;
23869 wxTimeSpan result;
23870 char *kwnames[] = {
23871 NULL
23872 };
23873
23874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 result = wxTimeSpan::Hour();
23878
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 {
23883 wxTimeSpan * resultptr;
23884 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23886 }
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj;
23895 long arg1 ;
23896 wxTimeSpan result;
23897 PyObject * obj0 = 0 ;
23898 char *kwnames[] = {
23899 (char *) "days", NULL
23900 };
23901
23902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23903 {
23904 arg1 = (long)(SWIG_As_long(obj0));
23905 if (SWIG_arg_fail(1)) SWIG_fail;
23906 }
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = wxTimeSpan::Days(arg1);
23910
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 wxTimeSpan * resultptr;
23916 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23917 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23918 }
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23926 PyObject *resultobj;
23927 wxTimeSpan result;
23928 char *kwnames[] = {
23929 NULL
23930 };
23931
23932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = wxTimeSpan::Day();
23936
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 {
23941 wxTimeSpan * resultptr;
23942 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23944 }
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj;
23953 long arg1 ;
23954 wxTimeSpan result;
23955 PyObject * obj0 = 0 ;
23956 char *kwnames[] = {
23957 (char *) "days", NULL
23958 };
23959
23960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23961 {
23962 arg1 = (long)(SWIG_As_long(obj0));
23963 if (SWIG_arg_fail(1)) SWIG_fail;
23964 }
23965 {
23966 PyThreadState* __tstate = wxPyBeginAllowThreads();
23967 result = wxTimeSpan::Weeks(arg1);
23968
23969 wxPyEndAllowThreads(__tstate);
23970 if (PyErr_Occurred()) SWIG_fail;
23971 }
23972 {
23973 wxTimeSpan * resultptr;
23974 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23975 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23976 }
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23984 PyObject *resultobj;
23985 wxTimeSpan result;
23986 char *kwnames[] = {
23987 NULL
23988 };
23989
23990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = wxTimeSpan::Week();
23994
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 {
23999 wxTimeSpan * resultptr;
24000 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24002 }
24003 return resultobj;
24004 fail:
24005 return NULL;
24006 }
24007
24008
24009 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24010 PyObject *resultobj;
24011 long arg1 = (long) 0 ;
24012 long arg2 = (long) 0 ;
24013 long arg3 = (long) 0 ;
24014 long arg4 = (long) 0 ;
24015 wxTimeSpan *result;
24016 PyObject * obj0 = 0 ;
24017 PyObject * obj1 = 0 ;
24018 PyObject * obj2 = 0 ;
24019 PyObject * obj3 = 0 ;
24020 char *kwnames[] = {
24021 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24022 };
24023
24024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24025 if (obj0) {
24026 {
24027 arg1 = (long)(SWIG_As_long(obj0));
24028 if (SWIG_arg_fail(1)) SWIG_fail;
24029 }
24030 }
24031 if (obj1) {
24032 {
24033 arg2 = (long)(SWIG_As_long(obj1));
24034 if (SWIG_arg_fail(2)) SWIG_fail;
24035 }
24036 }
24037 if (obj2) {
24038 {
24039 arg3 = (long)(SWIG_As_long(obj2));
24040 if (SWIG_arg_fail(3)) SWIG_fail;
24041 }
24042 }
24043 if (obj3) {
24044 {
24045 arg4 = (long)(SWIG_As_long(obj3));
24046 if (SWIG_arg_fail(4)) SWIG_fail;
24047 }
24048 }
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24052
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24057 return resultobj;
24058 fail:
24059 return NULL;
24060 }
24061
24062
24063 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24064 PyObject *resultobj;
24065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24066 PyObject * obj0 = 0 ;
24067 char *kwnames[] = {
24068 (char *) "self", NULL
24069 };
24070
24071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24073 if (SWIG_arg_fail(1)) SWIG_fail;
24074 {
24075 PyThreadState* __tstate = wxPyBeginAllowThreads();
24076 delete arg1;
24077
24078 wxPyEndAllowThreads(__tstate);
24079 if (PyErr_Occurred()) SWIG_fail;
24080 }
24081 Py_INCREF(Py_None); resultobj = Py_None;
24082 return resultobj;
24083 fail:
24084 return NULL;
24085 }
24086
24087
24088 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24089 PyObject *resultobj;
24090 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24091 wxTimeSpan *arg2 = 0 ;
24092 wxTimeSpan *result;
24093 PyObject * obj0 = 0 ;
24094 PyObject * obj1 = 0 ;
24095 char *kwnames[] = {
24096 (char *) "self",(char *) "diff", NULL
24097 };
24098
24099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24101 if (SWIG_arg_fail(1)) SWIG_fail;
24102 {
24103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24104 if (SWIG_arg_fail(2)) SWIG_fail;
24105 if (arg2 == NULL) {
24106 SWIG_null_ref("wxTimeSpan");
24107 }
24108 if (SWIG_arg_fail(2)) SWIG_fail;
24109 }
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 {
24113 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24114 result = (wxTimeSpan *) &_result_ref;
24115 }
24116
24117 wxPyEndAllowThreads(__tstate);
24118 if (PyErr_Occurred()) SWIG_fail;
24119 }
24120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24128 PyObject *resultobj;
24129 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24130 wxTimeSpan *arg2 = 0 ;
24131 wxTimeSpan *result;
24132 PyObject * obj0 = 0 ;
24133 PyObject * obj1 = 0 ;
24134 char *kwnames[] = {
24135 (char *) "self",(char *) "diff", NULL
24136 };
24137
24138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24140 if (SWIG_arg_fail(1)) SWIG_fail;
24141 {
24142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24143 if (SWIG_arg_fail(2)) SWIG_fail;
24144 if (arg2 == NULL) {
24145 SWIG_null_ref("wxTimeSpan");
24146 }
24147 if (SWIG_arg_fail(2)) SWIG_fail;
24148 }
24149 {
24150 PyThreadState* __tstate = wxPyBeginAllowThreads();
24151 {
24152 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24153 result = (wxTimeSpan *) &_result_ref;
24154 }
24155
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24169 int arg2 ;
24170 wxTimeSpan *result;
24171 PyObject * obj0 = 0 ;
24172 PyObject * obj1 = 0 ;
24173 char *kwnames[] = {
24174 (char *) "self",(char *) "n", NULL
24175 };
24176
24177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24179 if (SWIG_arg_fail(1)) SWIG_fail;
24180 {
24181 arg2 = (int)(SWIG_As_int(obj1));
24182 if (SWIG_arg_fail(2)) SWIG_fail;
24183 }
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 {
24187 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24188 result = (wxTimeSpan *) &_result_ref;
24189 }
24190
24191 wxPyEndAllowThreads(__tstate);
24192 if (PyErr_Occurred()) SWIG_fail;
24193 }
24194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24195 return resultobj;
24196 fail:
24197 return NULL;
24198 }
24199
24200
24201 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24202 PyObject *resultobj;
24203 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24204 wxTimeSpan *result;
24205 PyObject * obj0 = 0 ;
24206 char *kwnames[] = {
24207 (char *) "self", NULL
24208 };
24209
24210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24212 if (SWIG_arg_fail(1)) SWIG_fail;
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 {
24216 wxTimeSpan &_result_ref = (arg1)->Neg();
24217 result = (wxTimeSpan *) &_result_ref;
24218 }
24219
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24233 wxTimeSpan result;
24234 PyObject * obj0 = 0 ;
24235 char *kwnames[] = {
24236 (char *) "self", NULL
24237 };
24238
24239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24241 if (SWIG_arg_fail(1)) SWIG_fail;
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 result = ((wxTimeSpan const *)arg1)->Abs();
24245
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 {
24250 wxTimeSpan * resultptr;
24251 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24253 }
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24261 PyObject *resultobj;
24262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24263 wxTimeSpan *arg2 = 0 ;
24264 wxTimeSpan *result;
24265 PyObject * obj0 = 0 ;
24266 PyObject * obj1 = 0 ;
24267 char *kwnames[] = {
24268 (char *) "self",(char *) "diff", NULL
24269 };
24270
24271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24273 if (SWIG_arg_fail(1)) SWIG_fail;
24274 {
24275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24276 if (SWIG_arg_fail(2)) SWIG_fail;
24277 if (arg2 == NULL) {
24278 SWIG_null_ref("wxTimeSpan");
24279 }
24280 if (SWIG_arg_fail(2)) SWIG_fail;
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 {
24285 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24286 result = (wxTimeSpan *) &_result_ref;
24287 }
24288
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24300 PyObject *resultobj;
24301 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24302 wxTimeSpan *arg2 = 0 ;
24303 wxTimeSpan *result;
24304 PyObject * obj0 = 0 ;
24305 PyObject * obj1 = 0 ;
24306 char *kwnames[] = {
24307 (char *) "self",(char *) "diff", NULL
24308 };
24309
24310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24312 if (SWIG_arg_fail(1)) SWIG_fail;
24313 {
24314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24315 if (SWIG_arg_fail(2)) SWIG_fail;
24316 if (arg2 == NULL) {
24317 SWIG_null_ref("wxTimeSpan");
24318 }
24319 if (SWIG_arg_fail(2)) SWIG_fail;
24320 }
24321 {
24322 PyThreadState* __tstate = wxPyBeginAllowThreads();
24323 {
24324 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24325 result = (wxTimeSpan *) &_result_ref;
24326 }
24327
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24339 PyObject *resultobj;
24340 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24341 int arg2 ;
24342 wxTimeSpan *result;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char *kwnames[] = {
24346 (char *) "self",(char *) "n", NULL
24347 };
24348
24349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24351 if (SWIG_arg_fail(1)) SWIG_fail;
24352 {
24353 arg2 = (int)(SWIG_As_int(obj1));
24354 if (SWIG_arg_fail(2)) SWIG_fail;
24355 }
24356 {
24357 PyThreadState* __tstate = wxPyBeginAllowThreads();
24358 {
24359 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24360 result = (wxTimeSpan *) &_result_ref;
24361 }
24362
24363 wxPyEndAllowThreads(__tstate);
24364 if (PyErr_Occurred()) SWIG_fail;
24365 }
24366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24367 return resultobj;
24368 fail:
24369 return NULL;
24370 }
24371
24372
24373 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24374 PyObject *resultobj;
24375 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24376 wxTimeSpan *result;
24377 PyObject * obj0 = 0 ;
24378 char *kwnames[] = {
24379 (char *) "self", NULL
24380 };
24381
24382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24384 if (SWIG_arg_fail(1)) SWIG_fail;
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 {
24388 wxTimeSpan &_result_ref = (arg1)->operator -();
24389 result = (wxTimeSpan *) &_result_ref;
24390 }
24391
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24405 wxTimeSpan *arg2 = 0 ;
24406 wxTimeSpan result;
24407 PyObject * obj0 = 0 ;
24408 PyObject * obj1 = 0 ;
24409 char *kwnames[] = {
24410 (char *) "self",(char *) "other", NULL
24411 };
24412
24413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24415 if (SWIG_arg_fail(1)) SWIG_fail;
24416 {
24417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(2)) SWIG_fail;
24419 if (arg2 == NULL) {
24420 SWIG_null_ref("wxTimeSpan");
24421 }
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 {
24425 PyThreadState* __tstate = wxPyBeginAllowThreads();
24426 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24427
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 {
24432 wxTimeSpan * resultptr;
24433 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24435 }
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj;
24444 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24445 wxTimeSpan *arg2 = 0 ;
24446 wxTimeSpan result;
24447 PyObject * obj0 = 0 ;
24448 PyObject * obj1 = 0 ;
24449 char *kwnames[] = {
24450 (char *) "self",(char *) "other", NULL
24451 };
24452
24453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24455 if (SWIG_arg_fail(1)) SWIG_fail;
24456 {
24457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24458 if (SWIG_arg_fail(2)) SWIG_fail;
24459 if (arg2 == NULL) {
24460 SWIG_null_ref("wxTimeSpan");
24461 }
24462 if (SWIG_arg_fail(2)) SWIG_fail;
24463 }
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24467
24468 wxPyEndAllowThreads(__tstate);
24469 if (PyErr_Occurred()) SWIG_fail;
24470 }
24471 {
24472 wxTimeSpan * resultptr;
24473 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24475 }
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24483 PyObject *resultobj;
24484 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24485 int arg2 ;
24486 wxTimeSpan result;
24487 PyObject * obj0 = 0 ;
24488 PyObject * obj1 = 0 ;
24489 char *kwnames[] = {
24490 (char *) "self",(char *) "n", NULL
24491 };
24492
24493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24495 if (SWIG_arg_fail(1)) SWIG_fail;
24496 {
24497 arg2 = (int)(SWIG_As_int(obj1));
24498 if (SWIG_arg_fail(2)) SWIG_fail;
24499 }
24500 {
24501 PyThreadState* __tstate = wxPyBeginAllowThreads();
24502 result = wxTimeSpan___mul__(arg1,arg2);
24503
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 {
24508 wxTimeSpan * resultptr;
24509 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24510 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24511 }
24512 return resultobj;
24513 fail:
24514 return NULL;
24515 }
24516
24517
24518 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24519 PyObject *resultobj;
24520 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24521 int arg2 ;
24522 wxTimeSpan result;
24523 PyObject * obj0 = 0 ;
24524 PyObject * obj1 = 0 ;
24525 char *kwnames[] = {
24526 (char *) "self",(char *) "n", NULL
24527 };
24528
24529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24531 if (SWIG_arg_fail(1)) SWIG_fail;
24532 {
24533 arg2 = (int)(SWIG_As_int(obj1));
24534 if (SWIG_arg_fail(2)) SWIG_fail;
24535 }
24536 {
24537 PyThreadState* __tstate = wxPyBeginAllowThreads();
24538 result = wxTimeSpan___rmul__(arg1,arg2);
24539
24540 wxPyEndAllowThreads(__tstate);
24541 if (PyErr_Occurred()) SWIG_fail;
24542 }
24543 {
24544 wxTimeSpan * resultptr;
24545 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24555 PyObject *resultobj;
24556 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24557 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24558 bool result;
24559 PyObject * obj0 = 0 ;
24560 PyObject * obj1 = 0 ;
24561 char *kwnames[] = {
24562 (char *) "self",(char *) "other", NULL
24563 };
24564
24565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24567 if (SWIG_arg_fail(1)) SWIG_fail;
24568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24569 if (SWIG_arg_fail(2)) SWIG_fail;
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24573
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 {
24578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24579 }
24580 return resultobj;
24581 fail:
24582 return NULL;
24583 }
24584
24585
24586 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj;
24588 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24589 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24590 bool result;
24591 PyObject * obj0 = 0 ;
24592 PyObject * obj1 = 0 ;
24593 char *kwnames[] = {
24594 (char *) "self",(char *) "other", NULL
24595 };
24596
24597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24599 if (SWIG_arg_fail(1)) SWIG_fail;
24600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24601 if (SWIG_arg_fail(2)) SWIG_fail;
24602 {
24603 PyThreadState* __tstate = wxPyBeginAllowThreads();
24604 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24605
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 {
24610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24611 }
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj;
24620 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24621 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24622 bool result;
24623 PyObject * obj0 = 0 ;
24624 PyObject * obj1 = 0 ;
24625 char *kwnames[] = {
24626 (char *) "self",(char *) "other", NULL
24627 };
24628
24629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24631 if (SWIG_arg_fail(1)) SWIG_fail;
24632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24633 if (SWIG_arg_fail(2)) SWIG_fail;
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24637
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 {
24642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24643 }
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj;
24652 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24653 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24654 bool result;
24655 PyObject * obj0 = 0 ;
24656 PyObject * obj1 = 0 ;
24657 char *kwnames[] = {
24658 (char *) "self",(char *) "other", NULL
24659 };
24660
24661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24663 if (SWIG_arg_fail(1)) SWIG_fail;
24664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24665 if (SWIG_arg_fail(2)) SWIG_fail;
24666 {
24667 PyThreadState* __tstate = wxPyBeginAllowThreads();
24668 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24669
24670 wxPyEndAllowThreads(__tstate);
24671 if (PyErr_Occurred()) SWIG_fail;
24672 }
24673 {
24674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24675 }
24676 return resultobj;
24677 fail:
24678 return NULL;
24679 }
24680
24681
24682 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24683 PyObject *resultobj;
24684 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24685 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24686 bool result;
24687 PyObject * obj0 = 0 ;
24688 PyObject * obj1 = 0 ;
24689 char *kwnames[] = {
24690 (char *) "self",(char *) "other", NULL
24691 };
24692
24693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24695 if (SWIG_arg_fail(1)) SWIG_fail;
24696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24697 if (SWIG_arg_fail(2)) SWIG_fail;
24698 {
24699 PyThreadState* __tstate = wxPyBeginAllowThreads();
24700 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24701
24702 wxPyEndAllowThreads(__tstate);
24703 if (PyErr_Occurred()) SWIG_fail;
24704 }
24705 {
24706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24707 }
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj;
24716 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24717 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24718 bool result;
24719 PyObject * obj0 = 0 ;
24720 PyObject * obj1 = 0 ;
24721 char *kwnames[] = {
24722 (char *) "self",(char *) "other", NULL
24723 };
24724
24725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24727 if (SWIG_arg_fail(1)) SWIG_fail;
24728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24729 if (SWIG_arg_fail(2)) SWIG_fail;
24730 {
24731 PyThreadState* __tstate = wxPyBeginAllowThreads();
24732 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24733
24734 wxPyEndAllowThreads(__tstate);
24735 if (PyErr_Occurred()) SWIG_fail;
24736 }
24737 {
24738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24739 }
24740 return resultobj;
24741 fail:
24742 return NULL;
24743 }
24744
24745
24746 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj;
24748 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24749 bool result;
24750 PyObject * obj0 = 0 ;
24751 char *kwnames[] = {
24752 (char *) "self", NULL
24753 };
24754
24755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24757 if (SWIG_arg_fail(1)) SWIG_fail;
24758 {
24759 PyThreadState* __tstate = wxPyBeginAllowThreads();
24760 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24761
24762 wxPyEndAllowThreads(__tstate);
24763 if (PyErr_Occurred()) SWIG_fail;
24764 }
24765 {
24766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24767 }
24768 return resultobj;
24769 fail:
24770 return NULL;
24771 }
24772
24773
24774 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24775 PyObject *resultobj;
24776 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24777 bool result;
24778 PyObject * obj0 = 0 ;
24779 char *kwnames[] = {
24780 (char *) "self", NULL
24781 };
24782
24783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24785 if (SWIG_arg_fail(1)) SWIG_fail;
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24789
24790 wxPyEndAllowThreads(__tstate);
24791 if (PyErr_Occurred()) SWIG_fail;
24792 }
24793 {
24794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24795 }
24796 return resultobj;
24797 fail:
24798 return NULL;
24799 }
24800
24801
24802 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24803 PyObject *resultobj;
24804 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24805 bool result;
24806 PyObject * obj0 = 0 ;
24807 char *kwnames[] = {
24808 (char *) "self", NULL
24809 };
24810
24811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24813 if (SWIG_arg_fail(1)) SWIG_fail;
24814 {
24815 PyThreadState* __tstate = wxPyBeginAllowThreads();
24816 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24817
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 {
24822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24823 }
24824 return resultobj;
24825 fail:
24826 return NULL;
24827 }
24828
24829
24830 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj;
24832 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24833 wxTimeSpan *arg2 = 0 ;
24834 bool result;
24835 PyObject * obj0 = 0 ;
24836 PyObject * obj1 = 0 ;
24837 char *kwnames[] = {
24838 (char *) "self",(char *) "ts", NULL
24839 };
24840
24841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24843 if (SWIG_arg_fail(1)) SWIG_fail;
24844 {
24845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24846 if (SWIG_arg_fail(2)) SWIG_fail;
24847 if (arg2 == NULL) {
24848 SWIG_null_ref("wxTimeSpan");
24849 }
24850 if (SWIG_arg_fail(2)) SWIG_fail;
24851 }
24852 {
24853 PyThreadState* __tstate = wxPyBeginAllowThreads();
24854 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24855
24856 wxPyEndAllowThreads(__tstate);
24857 if (PyErr_Occurred()) SWIG_fail;
24858 }
24859 {
24860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24861 }
24862 return resultobj;
24863 fail:
24864 return NULL;
24865 }
24866
24867
24868 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24869 PyObject *resultobj;
24870 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24871 wxTimeSpan *arg2 = 0 ;
24872 bool result;
24873 PyObject * obj0 = 0 ;
24874 PyObject * obj1 = 0 ;
24875 char *kwnames[] = {
24876 (char *) "self",(char *) "ts", NULL
24877 };
24878
24879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24881 if (SWIG_arg_fail(1)) SWIG_fail;
24882 {
24883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24884 if (SWIG_arg_fail(2)) SWIG_fail;
24885 if (arg2 == NULL) {
24886 SWIG_null_ref("wxTimeSpan");
24887 }
24888 if (SWIG_arg_fail(2)) SWIG_fail;
24889 }
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24893
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj;
24908 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24909 wxTimeSpan *arg2 = 0 ;
24910 bool result;
24911 PyObject * obj0 = 0 ;
24912 PyObject * obj1 = 0 ;
24913 char *kwnames[] = {
24914 (char *) "self",(char *) "t", NULL
24915 };
24916
24917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24919 if (SWIG_arg_fail(1)) SWIG_fail;
24920 {
24921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24922 if (SWIG_arg_fail(2)) SWIG_fail;
24923 if (arg2 == NULL) {
24924 SWIG_null_ref("wxTimeSpan");
24925 }
24926 if (SWIG_arg_fail(2)) SWIG_fail;
24927 }
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24947 int result;
24948 PyObject * obj0 = 0 ;
24949 char *kwnames[] = {
24950 (char *) "self", NULL
24951 };
24952
24953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24955 if (SWIG_arg_fail(1)) SWIG_fail;
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24959
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 {
24964 resultobj = SWIG_From_int((int)(result));
24965 }
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj;
24974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24975 int result;
24976 PyObject * obj0 = 0 ;
24977 char *kwnames[] = {
24978 (char *) "self", NULL
24979 };
24980
24981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24983 if (SWIG_arg_fail(1)) SWIG_fail;
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24987
24988 wxPyEndAllowThreads(__tstate);
24989 if (PyErr_Occurred()) SWIG_fail;
24990 }
24991 {
24992 resultobj = SWIG_From_int((int)(result));
24993 }
24994 return resultobj;
24995 fail:
24996 return NULL;
24997 }
24998
24999
25000 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25001 PyObject *resultobj;
25002 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25003 int result;
25004 PyObject * obj0 = 0 ;
25005 char *kwnames[] = {
25006 (char *) "self", NULL
25007 };
25008
25009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25011 if (SWIG_arg_fail(1)) SWIG_fail;
25012 {
25013 PyThreadState* __tstate = wxPyBeginAllowThreads();
25014 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25015
25016 wxPyEndAllowThreads(__tstate);
25017 if (PyErr_Occurred()) SWIG_fail;
25018 }
25019 {
25020 resultobj = SWIG_From_int((int)(result));
25021 }
25022 return resultobj;
25023 fail:
25024 return NULL;
25025 }
25026
25027
25028 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25029 PyObject *resultobj;
25030 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25031 int result;
25032 PyObject * obj0 = 0 ;
25033 char *kwnames[] = {
25034 (char *) "self", NULL
25035 };
25036
25037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25039 if (SWIG_arg_fail(1)) SWIG_fail;
25040 {
25041 PyThreadState* __tstate = wxPyBeginAllowThreads();
25042 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25043
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 {
25048 resultobj = SWIG_From_int((int)(result));
25049 }
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25057 PyObject *resultobj;
25058 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25059 wxLongLong result;
25060 PyObject * obj0 = 0 ;
25061 char *kwnames[] = {
25062 (char *) "self", NULL
25063 };
25064
25065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25067 if (SWIG_arg_fail(1)) SWIG_fail;
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25071
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 {
25076 PyObject *hi, *lo, *shifter, *shifted;
25077 hi = PyLong_FromLong( (&result)->GetHi() );
25078 lo = PyLong_FromLong( (&result)->GetLo() );
25079 shifter = PyLong_FromLong(32);
25080 shifted = PyNumber_Lshift(hi, shifter);
25081 resultobj = PyNumber_Or(shifted, lo);
25082 Py_DECREF(hi);
25083 Py_DECREF(lo);
25084 Py_DECREF(shifter);
25085 Py_DECREF(shifted);
25086 }
25087 return resultobj;
25088 fail:
25089 return NULL;
25090 }
25091
25092
25093 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25094 PyObject *resultobj;
25095 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25096 wxLongLong result;
25097 PyObject * obj0 = 0 ;
25098 char *kwnames[] = {
25099 (char *) "self", NULL
25100 };
25101
25102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25104 if (SWIG_arg_fail(1)) SWIG_fail;
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25108
25109 wxPyEndAllowThreads(__tstate);
25110 if (PyErr_Occurred()) SWIG_fail;
25111 }
25112 {
25113 PyObject *hi, *lo, *shifter, *shifted;
25114 hi = PyLong_FromLong( (&result)->GetHi() );
25115 lo = PyLong_FromLong( (&result)->GetLo() );
25116 shifter = PyLong_FromLong(32);
25117 shifted = PyNumber_Lshift(hi, shifter);
25118 resultobj = PyNumber_Or(shifted, lo);
25119 Py_DECREF(hi);
25120 Py_DECREF(lo);
25121 Py_DECREF(shifter);
25122 Py_DECREF(shifted);
25123 }
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25131 PyObject *resultobj;
25132 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25133 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25134 wxString *arg2 = (wxString *) &arg2_defvalue ;
25135 wxString result;
25136 bool temp2 = false ;
25137 PyObject * obj0 = 0 ;
25138 PyObject * obj1 = 0 ;
25139 char *kwnames[] = {
25140 (char *) "self",(char *) "format", NULL
25141 };
25142
25143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25145 if (SWIG_arg_fail(1)) SWIG_fail;
25146 if (obj1) {
25147 {
25148 arg2 = wxString_in_helper(obj1);
25149 if (arg2 == NULL) SWIG_fail;
25150 temp2 = true;
25151 }
25152 }
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25156
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 #if wxUSE_UNICODE
25162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25163 #else
25164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25165 #endif
25166 }
25167 {
25168 if (temp2)
25169 delete arg2;
25170 }
25171 return resultobj;
25172 fail:
25173 {
25174 if (temp2)
25175 delete arg2;
25176 }
25177 return NULL;
25178 }
25179
25180
25181 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25182 PyObject *obj;
25183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25184 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25185 Py_INCREF(obj);
25186 return Py_BuildValue((char *)"");
25187 }
25188 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj;
25190 int arg1 = (int) 0 ;
25191 int arg2 = (int) 0 ;
25192 int arg3 = (int) 0 ;
25193 int arg4 = (int) 0 ;
25194 wxDateSpan *result;
25195 PyObject * obj0 = 0 ;
25196 PyObject * obj1 = 0 ;
25197 PyObject * obj2 = 0 ;
25198 PyObject * obj3 = 0 ;
25199 char *kwnames[] = {
25200 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25201 };
25202
25203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25204 if (obj0) {
25205 {
25206 arg1 = (int)(SWIG_As_int(obj0));
25207 if (SWIG_arg_fail(1)) SWIG_fail;
25208 }
25209 }
25210 if (obj1) {
25211 {
25212 arg2 = (int)(SWIG_As_int(obj1));
25213 if (SWIG_arg_fail(2)) SWIG_fail;
25214 }
25215 }
25216 if (obj2) {
25217 {
25218 arg3 = (int)(SWIG_As_int(obj2));
25219 if (SWIG_arg_fail(3)) SWIG_fail;
25220 }
25221 }
25222 if (obj3) {
25223 {
25224 arg4 = (int)(SWIG_As_int(obj3));
25225 if (SWIG_arg_fail(4)) SWIG_fail;
25226 }
25227 }
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25231
25232 wxPyEndAllowThreads(__tstate);
25233 if (PyErr_Occurred()) SWIG_fail;
25234 }
25235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25236 return resultobj;
25237 fail:
25238 return NULL;
25239 }
25240
25241
25242 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25243 PyObject *resultobj;
25244 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25245 PyObject * obj0 = 0 ;
25246 char *kwnames[] = {
25247 (char *) "self", NULL
25248 };
25249
25250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25252 if (SWIG_arg_fail(1)) SWIG_fail;
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 delete arg1;
25256
25257 wxPyEndAllowThreads(__tstate);
25258 if (PyErr_Occurred()) SWIG_fail;
25259 }
25260 Py_INCREF(Py_None); resultobj = Py_None;
25261 return resultobj;
25262 fail:
25263 return NULL;
25264 }
25265
25266
25267 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25268 PyObject *resultobj;
25269 int arg1 ;
25270 wxDateSpan result;
25271 PyObject * obj0 = 0 ;
25272 char *kwnames[] = {
25273 (char *) "days", NULL
25274 };
25275
25276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25277 {
25278 arg1 = (int)(SWIG_As_int(obj0));
25279 if (SWIG_arg_fail(1)) SWIG_fail;
25280 }
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = wxDateSpan::Days(arg1);
25284
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 {
25289 wxDateSpan * resultptr;
25290 resultptr = new wxDateSpan((wxDateSpan &)(result));
25291 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25292 }
25293 return resultobj;
25294 fail:
25295 return NULL;
25296 }
25297
25298
25299 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25300 PyObject *resultobj;
25301 wxDateSpan result;
25302 char *kwnames[] = {
25303 NULL
25304 };
25305
25306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 result = wxDateSpan::Day();
25310
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 {
25315 wxDateSpan * resultptr;
25316 resultptr = new wxDateSpan((wxDateSpan &)(result));
25317 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25318 }
25319 return resultobj;
25320 fail:
25321 return NULL;
25322 }
25323
25324
25325 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25326 PyObject *resultobj;
25327 int arg1 ;
25328 wxDateSpan result;
25329 PyObject * obj0 = 0 ;
25330 char *kwnames[] = {
25331 (char *) "weeks", NULL
25332 };
25333
25334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25335 {
25336 arg1 = (int)(SWIG_As_int(obj0));
25337 if (SWIG_arg_fail(1)) SWIG_fail;
25338 }
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 result = wxDateSpan::Weeks(arg1);
25342
25343 wxPyEndAllowThreads(__tstate);
25344 if (PyErr_Occurred()) SWIG_fail;
25345 }
25346 {
25347 wxDateSpan * resultptr;
25348 resultptr = new wxDateSpan((wxDateSpan &)(result));
25349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25350 }
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj;
25359 wxDateSpan result;
25360 char *kwnames[] = {
25361 NULL
25362 };
25363
25364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 result = wxDateSpan::Week();
25368
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 {
25373 wxDateSpan * resultptr;
25374 resultptr = new wxDateSpan((wxDateSpan &)(result));
25375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25376 }
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj;
25385 int arg1 ;
25386 wxDateSpan result;
25387 PyObject * obj0 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "mon", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25393 {
25394 arg1 = (int)(SWIG_As_int(obj0));
25395 if (SWIG_arg_fail(1)) SWIG_fail;
25396 }
25397 {
25398 PyThreadState* __tstate = wxPyBeginAllowThreads();
25399 result = wxDateSpan::Months(arg1);
25400
25401 wxPyEndAllowThreads(__tstate);
25402 if (PyErr_Occurred()) SWIG_fail;
25403 }
25404 {
25405 wxDateSpan * resultptr;
25406 resultptr = new wxDateSpan((wxDateSpan &)(result));
25407 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25408 }
25409 return resultobj;
25410 fail:
25411 return NULL;
25412 }
25413
25414
25415 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25416 PyObject *resultobj;
25417 wxDateSpan result;
25418 char *kwnames[] = {
25419 NULL
25420 };
25421
25422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25423 {
25424 PyThreadState* __tstate = wxPyBeginAllowThreads();
25425 result = wxDateSpan::Month();
25426
25427 wxPyEndAllowThreads(__tstate);
25428 if (PyErr_Occurred()) SWIG_fail;
25429 }
25430 {
25431 wxDateSpan * resultptr;
25432 resultptr = new wxDateSpan((wxDateSpan &)(result));
25433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25434 }
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj;
25443 int arg1 ;
25444 wxDateSpan result;
25445 PyObject * obj0 = 0 ;
25446 char *kwnames[] = {
25447 (char *) "years", NULL
25448 };
25449
25450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25451 {
25452 arg1 = (int)(SWIG_As_int(obj0));
25453 if (SWIG_arg_fail(1)) SWIG_fail;
25454 }
25455 {
25456 PyThreadState* __tstate = wxPyBeginAllowThreads();
25457 result = wxDateSpan::Years(arg1);
25458
25459 wxPyEndAllowThreads(__tstate);
25460 if (PyErr_Occurred()) SWIG_fail;
25461 }
25462 {
25463 wxDateSpan * resultptr;
25464 resultptr = new wxDateSpan((wxDateSpan &)(result));
25465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25466 }
25467 return resultobj;
25468 fail:
25469 return NULL;
25470 }
25471
25472
25473 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25474 PyObject *resultobj;
25475 wxDateSpan result;
25476 char *kwnames[] = {
25477 NULL
25478 };
25479
25480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25481 {
25482 PyThreadState* __tstate = wxPyBeginAllowThreads();
25483 result = wxDateSpan::Year();
25484
25485 wxPyEndAllowThreads(__tstate);
25486 if (PyErr_Occurred()) SWIG_fail;
25487 }
25488 {
25489 wxDateSpan * resultptr;
25490 resultptr = new wxDateSpan((wxDateSpan &)(result));
25491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25492 }
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj;
25501 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25502 int arg2 ;
25503 wxDateSpan *result;
25504 PyObject * obj0 = 0 ;
25505 PyObject * obj1 = 0 ;
25506 char *kwnames[] = {
25507 (char *) "self",(char *) "n", NULL
25508 };
25509
25510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25512 if (SWIG_arg_fail(1)) SWIG_fail;
25513 {
25514 arg2 = (int)(SWIG_As_int(obj1));
25515 if (SWIG_arg_fail(2)) SWIG_fail;
25516 }
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 {
25520 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25521 result = (wxDateSpan *) &_result_ref;
25522 }
25523
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25528 return resultobj;
25529 fail:
25530 return NULL;
25531 }
25532
25533
25534 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25535 PyObject *resultobj;
25536 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25537 int arg2 ;
25538 wxDateSpan *result;
25539 PyObject * obj0 = 0 ;
25540 PyObject * obj1 = 0 ;
25541 char *kwnames[] = {
25542 (char *) "self",(char *) "n", NULL
25543 };
25544
25545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25547 if (SWIG_arg_fail(1)) SWIG_fail;
25548 {
25549 arg2 = (int)(SWIG_As_int(obj1));
25550 if (SWIG_arg_fail(2)) SWIG_fail;
25551 }
25552 {
25553 PyThreadState* __tstate = wxPyBeginAllowThreads();
25554 {
25555 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25556 result = (wxDateSpan *) &_result_ref;
25557 }
25558
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj;
25571 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25572 int arg2 ;
25573 wxDateSpan *result;
25574 PyObject * obj0 = 0 ;
25575 PyObject * obj1 = 0 ;
25576 char *kwnames[] = {
25577 (char *) "self",(char *) "n", NULL
25578 };
25579
25580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25582 if (SWIG_arg_fail(1)) SWIG_fail;
25583 {
25584 arg2 = (int)(SWIG_As_int(obj1));
25585 if (SWIG_arg_fail(2)) SWIG_fail;
25586 }
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 {
25590 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25591 result = (wxDateSpan *) &_result_ref;
25592 }
25593
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25605 PyObject *resultobj;
25606 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25607 int arg2 ;
25608 wxDateSpan *result;
25609 PyObject * obj0 = 0 ;
25610 PyObject * obj1 = 0 ;
25611 char *kwnames[] = {
25612 (char *) "self",(char *) "n", NULL
25613 };
25614
25615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25617 if (SWIG_arg_fail(1)) SWIG_fail;
25618 {
25619 arg2 = (int)(SWIG_As_int(obj1));
25620 if (SWIG_arg_fail(2)) SWIG_fail;
25621 }
25622 {
25623 PyThreadState* __tstate = wxPyBeginAllowThreads();
25624 {
25625 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25626 result = (wxDateSpan *) &_result_ref;
25627 }
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25640 PyObject *resultobj;
25641 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25642 int result;
25643 PyObject * obj0 = 0 ;
25644 char *kwnames[] = {
25645 (char *) "self", NULL
25646 };
25647
25648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25650 if (SWIG_arg_fail(1)) SWIG_fail;
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = (int)((wxDateSpan const *)arg1)->GetYears();
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 {
25659 resultobj = SWIG_From_int((int)(result));
25660 }
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25670 int result;
25671 PyObject * obj0 = 0 ;
25672 char *kwnames[] = {
25673 (char *) "self", NULL
25674 };
25675
25676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25678 if (SWIG_arg_fail(1)) SWIG_fail;
25679 {
25680 PyThreadState* __tstate = wxPyBeginAllowThreads();
25681 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25682
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 {
25687 resultobj = SWIG_From_int((int)(result));
25688 }
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj;
25697 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25698 int result;
25699 PyObject * obj0 = 0 ;
25700 char *kwnames[] = {
25701 (char *) "self", NULL
25702 };
25703
25704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25706 if (SWIG_arg_fail(1)) SWIG_fail;
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25710
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 {
25715 resultobj = SWIG_From_int((int)(result));
25716 }
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj;
25725 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25726 int result;
25727 PyObject * obj0 = 0 ;
25728 char *kwnames[] = {
25729 (char *) "self", NULL
25730 };
25731
25732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25734 if (SWIG_arg_fail(1)) SWIG_fail;
25735 {
25736 PyThreadState* __tstate = wxPyBeginAllowThreads();
25737 result = (int)((wxDateSpan const *)arg1)->GetDays();
25738
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 {
25743 resultobj = SWIG_From_int((int)(result));
25744 }
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25752 PyObject *resultobj;
25753 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25754 int result;
25755 PyObject * obj0 = 0 ;
25756 char *kwnames[] = {
25757 (char *) "self", NULL
25758 };
25759
25760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25762 if (SWIG_arg_fail(1)) SWIG_fail;
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25766
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 {
25771 resultobj = SWIG_From_int((int)(result));
25772 }
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj;
25781 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25782 wxDateSpan *arg2 = 0 ;
25783 wxDateSpan *result;
25784 PyObject * obj0 = 0 ;
25785 PyObject * obj1 = 0 ;
25786 char *kwnames[] = {
25787 (char *) "self",(char *) "other", NULL
25788 };
25789
25790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25792 if (SWIG_arg_fail(1)) SWIG_fail;
25793 {
25794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25795 if (SWIG_arg_fail(2)) SWIG_fail;
25796 if (arg2 == NULL) {
25797 SWIG_null_ref("wxDateSpan");
25798 }
25799 if (SWIG_arg_fail(2)) SWIG_fail;
25800 }
25801 {
25802 PyThreadState* __tstate = wxPyBeginAllowThreads();
25803 {
25804 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25805 result = (wxDateSpan *) &_result_ref;
25806 }
25807
25808 wxPyEndAllowThreads(__tstate);
25809 if (PyErr_Occurred()) SWIG_fail;
25810 }
25811 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25812 return resultobj;
25813 fail:
25814 return NULL;
25815 }
25816
25817
25818 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25819 PyObject *resultobj;
25820 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25821 wxDateSpan *arg2 = 0 ;
25822 wxDateSpan *result;
25823 PyObject * obj0 = 0 ;
25824 PyObject * obj1 = 0 ;
25825 char *kwnames[] = {
25826 (char *) "self",(char *) "other", NULL
25827 };
25828
25829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25831 if (SWIG_arg_fail(1)) SWIG_fail;
25832 {
25833 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25834 if (SWIG_arg_fail(2)) SWIG_fail;
25835 if (arg2 == NULL) {
25836 SWIG_null_ref("wxDateSpan");
25837 }
25838 if (SWIG_arg_fail(2)) SWIG_fail;
25839 }
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 {
25843 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25844 result = (wxDateSpan *) &_result_ref;
25845 }
25846
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25860 wxDateSpan *result;
25861 PyObject * obj0 = 0 ;
25862 char *kwnames[] = {
25863 (char *) "self", NULL
25864 };
25865
25866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25868 if (SWIG_arg_fail(1)) SWIG_fail;
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 {
25872 wxDateSpan &_result_ref = (arg1)->Neg();
25873 result = (wxDateSpan *) &_result_ref;
25874 }
25875
25876 wxPyEndAllowThreads(__tstate);
25877 if (PyErr_Occurred()) SWIG_fail;
25878 }
25879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25880 return resultobj;
25881 fail:
25882 return NULL;
25883 }
25884
25885
25886 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25887 PyObject *resultobj;
25888 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25889 int arg2 ;
25890 wxDateSpan *result;
25891 PyObject * obj0 = 0 ;
25892 PyObject * obj1 = 0 ;
25893 char *kwnames[] = {
25894 (char *) "self",(char *) "factor", NULL
25895 };
25896
25897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25899 if (SWIG_arg_fail(1)) SWIG_fail;
25900 {
25901 arg2 = (int)(SWIG_As_int(obj1));
25902 if (SWIG_arg_fail(2)) SWIG_fail;
25903 }
25904 {
25905 PyThreadState* __tstate = wxPyBeginAllowThreads();
25906 {
25907 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25908 result = (wxDateSpan *) &_result_ref;
25909 }
25910
25911 wxPyEndAllowThreads(__tstate);
25912 if (PyErr_Occurred()) SWIG_fail;
25913 }
25914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25924 wxDateSpan *arg2 = 0 ;
25925 wxDateSpan *result;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 char *kwnames[] = {
25929 (char *) "self",(char *) "other", NULL
25930 };
25931
25932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25934 if (SWIG_arg_fail(1)) SWIG_fail;
25935 {
25936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(2)) SWIG_fail;
25938 if (arg2 == NULL) {
25939 SWIG_null_ref("wxDateSpan");
25940 }
25941 if (SWIG_arg_fail(2)) SWIG_fail;
25942 }
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 {
25946 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25947 result = (wxDateSpan *) &_result_ref;
25948 }
25949
25950 wxPyEndAllowThreads(__tstate);
25951 if (PyErr_Occurred()) SWIG_fail;
25952 }
25953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25954 return resultobj;
25955 fail:
25956 return NULL;
25957 }
25958
25959
25960 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25961 PyObject *resultobj;
25962 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25963 wxDateSpan *arg2 = 0 ;
25964 wxDateSpan *result;
25965 PyObject * obj0 = 0 ;
25966 PyObject * obj1 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self",(char *) "other", NULL
25969 };
25970
25971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25973 if (SWIG_arg_fail(1)) SWIG_fail;
25974 {
25975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25976 if (SWIG_arg_fail(2)) SWIG_fail;
25977 if (arg2 == NULL) {
25978 SWIG_null_ref("wxDateSpan");
25979 }
25980 if (SWIG_arg_fail(2)) SWIG_fail;
25981 }
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 {
25985 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25986 result = (wxDateSpan *) &_result_ref;
25987 }
25988
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25993 return resultobj;
25994 fail:
25995 return NULL;
25996 }
25997
25998
25999 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj;
26001 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26002 wxDateSpan *result;
26003 PyObject * obj0 = 0 ;
26004 char *kwnames[] = {
26005 (char *) "self", NULL
26006 };
26007
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 {
26014 wxDateSpan &_result_ref = (arg1)->operator -();
26015 result = (wxDateSpan *) &_result_ref;
26016 }
26017
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26031 int arg2 ;
26032 wxDateSpan *result;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char *kwnames[] = {
26036 (char *) "self",(char *) "factor", NULL
26037 };
26038
26039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26041 if (SWIG_arg_fail(1)) SWIG_fail;
26042 {
26043 arg2 = (int)(SWIG_As_int(obj1));
26044 if (SWIG_arg_fail(2)) SWIG_fail;
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 {
26049 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26050 result = (wxDateSpan *) &_result_ref;
26051 }
26052
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj;
26065 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26066 wxDateSpan *arg2 = 0 ;
26067 wxDateSpan result;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 char *kwnames[] = {
26071 (char *) "self",(char *) "other", NULL
26072 };
26073
26074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26076 if (SWIG_arg_fail(1)) SWIG_fail;
26077 {
26078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26079 if (SWIG_arg_fail(2)) SWIG_fail;
26080 if (arg2 == NULL) {
26081 SWIG_null_ref("wxDateSpan");
26082 }
26083 if (SWIG_arg_fail(2)) SWIG_fail;
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26088
26089 wxPyEndAllowThreads(__tstate);
26090 if (PyErr_Occurred()) SWIG_fail;
26091 }
26092 {
26093 wxDateSpan * resultptr;
26094 resultptr = new wxDateSpan((wxDateSpan &)(result));
26095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26096 }
26097 return resultobj;
26098 fail:
26099 return NULL;
26100 }
26101
26102
26103 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26104 PyObject *resultobj;
26105 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26106 wxDateSpan *arg2 = 0 ;
26107 wxDateSpan result;
26108 PyObject * obj0 = 0 ;
26109 PyObject * obj1 = 0 ;
26110 char *kwnames[] = {
26111 (char *) "self",(char *) "other", NULL
26112 };
26113
26114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26116 if (SWIG_arg_fail(1)) SWIG_fail;
26117 {
26118 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26119 if (SWIG_arg_fail(2)) SWIG_fail;
26120 if (arg2 == NULL) {
26121 SWIG_null_ref("wxDateSpan");
26122 }
26123 if (SWIG_arg_fail(2)) SWIG_fail;
26124 }
26125 {
26126 PyThreadState* __tstate = wxPyBeginAllowThreads();
26127 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26128
26129 wxPyEndAllowThreads(__tstate);
26130 if (PyErr_Occurred()) SWIG_fail;
26131 }
26132 {
26133 wxDateSpan * resultptr;
26134 resultptr = new wxDateSpan((wxDateSpan &)(result));
26135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26136 }
26137 return resultobj;
26138 fail:
26139 return NULL;
26140 }
26141
26142
26143 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26144 PyObject *resultobj;
26145 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26146 int arg2 ;
26147 wxDateSpan result;
26148 PyObject * obj0 = 0 ;
26149 PyObject * obj1 = 0 ;
26150 char *kwnames[] = {
26151 (char *) "self",(char *) "n", NULL
26152 };
26153
26154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26156 if (SWIG_arg_fail(1)) SWIG_fail;
26157 {
26158 arg2 = (int)(SWIG_As_int(obj1));
26159 if (SWIG_arg_fail(2)) SWIG_fail;
26160 }
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 result = wxDateSpan___mul__(arg1,arg2);
26164
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 {
26169 wxDateSpan * resultptr;
26170 resultptr = new wxDateSpan((wxDateSpan &)(result));
26171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26172 }
26173 return resultobj;
26174 fail:
26175 return NULL;
26176 }
26177
26178
26179 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26180 PyObject *resultobj;
26181 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26182 int arg2 ;
26183 wxDateSpan result;
26184 PyObject * obj0 = 0 ;
26185 PyObject * obj1 = 0 ;
26186 char *kwnames[] = {
26187 (char *) "self",(char *) "n", NULL
26188 };
26189
26190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26192 if (SWIG_arg_fail(1)) SWIG_fail;
26193 {
26194 arg2 = (int)(SWIG_As_int(obj1));
26195 if (SWIG_arg_fail(2)) SWIG_fail;
26196 }
26197 {
26198 PyThreadState* __tstate = wxPyBeginAllowThreads();
26199 result = wxDateSpan___rmul__(arg1,arg2);
26200
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 {
26205 wxDateSpan * resultptr;
26206 resultptr = new wxDateSpan((wxDateSpan &)(result));
26207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26208 }
26209 return resultobj;
26210 fail:
26211 return NULL;
26212 }
26213
26214
26215 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26216 PyObject *resultobj;
26217 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26218 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26219 bool result;
26220 PyObject * obj0 = 0 ;
26221 PyObject * obj1 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self",(char *) "other", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26230 if (SWIG_arg_fail(2)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26240 }
26241 return resultobj;
26242 fail:
26243 return NULL;
26244 }
26245
26246
26247 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26248 PyObject *resultobj;
26249 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26250 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26251 bool result;
26252 PyObject * obj0 = 0 ;
26253 PyObject * obj1 = 0 ;
26254 char *kwnames[] = {
26255 (char *) "self",(char *) "other", NULL
26256 };
26257
26258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26260 if (SWIG_arg_fail(1)) SWIG_fail;
26261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(2)) SWIG_fail;
26263 {
26264 PyThreadState* __tstate = wxPyBeginAllowThreads();
26265 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26266
26267 wxPyEndAllowThreads(__tstate);
26268 if (PyErr_Occurred()) SWIG_fail;
26269 }
26270 {
26271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26272 }
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26280 PyObject *obj;
26281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26282 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26283 Py_INCREF(obj);
26284 return Py_BuildValue((char *)"");
26285 }
26286 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26287 PyObject *resultobj;
26288 long result;
26289 char *kwnames[] = {
26290 NULL
26291 };
26292
26293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 result = (long)wxGetLocalTime();
26297
26298 wxPyEndAllowThreads(__tstate);
26299 if (PyErr_Occurred()) SWIG_fail;
26300 }
26301 {
26302 resultobj = SWIG_From_long((long)(result));
26303 }
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26311 PyObject *resultobj;
26312 long result;
26313 char *kwnames[] = {
26314 NULL
26315 };
26316
26317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26318 {
26319 PyThreadState* __tstate = wxPyBeginAllowThreads();
26320 result = (long)wxGetUTCTime();
26321
26322 wxPyEndAllowThreads(__tstate);
26323 if (PyErr_Occurred()) SWIG_fail;
26324 }
26325 {
26326 resultobj = SWIG_From_long((long)(result));
26327 }
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26335 PyObject *resultobj;
26336 long result;
26337 char *kwnames[] = {
26338 NULL
26339 };
26340
26341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 result = (long)wxGetCurrentTime();
26345
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 {
26350 resultobj = SWIG_From_long((long)(result));
26351 }
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj;
26360 wxLongLong result;
26361 char *kwnames[] = {
26362 NULL
26363 };
26364
26365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 result = wxGetLocalTimeMillis();
26369
26370 wxPyEndAllowThreads(__tstate);
26371 if (PyErr_Occurred()) SWIG_fail;
26372 }
26373 {
26374 PyObject *hi, *lo, *shifter, *shifted;
26375 hi = PyLong_FromLong( (&result)->GetHi() );
26376 lo = PyLong_FromLong( (&result)->GetLo() );
26377 shifter = PyLong_FromLong(32);
26378 shifted = PyNumber_Lshift(hi, shifter);
26379 resultobj = PyNumber_Or(shifted, lo);
26380 Py_DECREF(hi);
26381 Py_DECREF(lo);
26382 Py_DECREF(shifter);
26383 Py_DECREF(shifted);
26384 }
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static int _wrap_DefaultDateTime_set(PyObject *) {
26392 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26393 return 1;
26394 }
26395
26396
26397 static PyObject *_wrap_DefaultDateTime_get(void) {
26398 PyObject *pyobj;
26399
26400 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26401 return pyobj;
26402 }
26403
26404
26405 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26406 PyObject *resultobj;
26407 wxDataFormatId arg1 ;
26408 wxDataFormat *result;
26409 PyObject * obj0 = 0 ;
26410 char *kwnames[] = {
26411 (char *) "type", NULL
26412 };
26413
26414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26415 {
26416 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26417 if (SWIG_arg_fail(1)) SWIG_fail;
26418 }
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26422
26423 wxPyEndAllowThreads(__tstate);
26424 if (PyErr_Occurred()) SWIG_fail;
26425 }
26426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26427 return resultobj;
26428 fail:
26429 return NULL;
26430 }
26431
26432
26433 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj;
26435 wxString *arg1 = 0 ;
26436 wxDataFormat *result;
26437 bool temp1 = false ;
26438 PyObject * obj0 = 0 ;
26439 char *kwnames[] = {
26440 (char *) "format", NULL
26441 };
26442
26443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26444 {
26445 arg1 = wxString_in_helper(obj0);
26446 if (arg1 == NULL) SWIG_fail;
26447 temp1 = true;
26448 }
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26452
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26457 {
26458 if (temp1)
26459 delete arg1;
26460 }
26461 return resultobj;
26462 fail:
26463 {
26464 if (temp1)
26465 delete arg1;
26466 }
26467 return NULL;
26468 }
26469
26470
26471 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26472 PyObject *resultobj;
26473 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26474 PyObject * obj0 = 0 ;
26475 char *kwnames[] = {
26476 (char *) "self", NULL
26477 };
26478
26479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26481 if (SWIG_arg_fail(1)) SWIG_fail;
26482 {
26483 PyThreadState* __tstate = wxPyBeginAllowThreads();
26484 delete arg1;
26485
26486 wxPyEndAllowThreads(__tstate);
26487 if (PyErr_Occurred()) SWIG_fail;
26488 }
26489 Py_INCREF(Py_None); resultobj = Py_None;
26490 return resultobj;
26491 fail:
26492 return NULL;
26493 }
26494
26495
26496 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26497 PyObject *resultobj;
26498 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26499 wxDataFormatId arg2 ;
26500 bool result;
26501 PyObject * obj0 = 0 ;
26502 PyObject * obj1 = 0 ;
26503
26504 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26506 if (SWIG_arg_fail(1)) SWIG_fail;
26507 {
26508 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26509 if (SWIG_arg_fail(2)) SWIG_fail;
26510 }
26511 {
26512 PyThreadState* __tstate = wxPyBeginAllowThreads();
26513 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26514
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 {
26519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26520 }
26521 return resultobj;
26522 fail:
26523 return NULL;
26524 }
26525
26526
26527 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26528 PyObject *resultobj;
26529 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26530 wxDataFormatId arg2 ;
26531 bool result;
26532 PyObject * obj0 = 0 ;
26533 PyObject * obj1 = 0 ;
26534
26535 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26537 if (SWIG_arg_fail(1)) SWIG_fail;
26538 {
26539 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26540 if (SWIG_arg_fail(2)) SWIG_fail;
26541 }
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26545
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 {
26550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26551 }
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26559 PyObject *resultobj;
26560 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26561 wxDataFormat *arg2 = 0 ;
26562 bool result;
26563 PyObject * obj0 = 0 ;
26564 PyObject * obj1 = 0 ;
26565
26566 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26568 if (SWIG_arg_fail(1)) SWIG_fail;
26569 {
26570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26571 if (SWIG_arg_fail(2)) SWIG_fail;
26572 if (arg2 == NULL) {
26573 SWIG_null_ref("wxDataFormat");
26574 }
26575 if (SWIG_arg_fail(2)) SWIG_fail;
26576 }
26577 {
26578 PyThreadState* __tstate = wxPyBeginAllowThreads();
26579 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26580
26581 wxPyEndAllowThreads(__tstate);
26582 if (PyErr_Occurred()) SWIG_fail;
26583 }
26584 {
26585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26586 }
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26594 int argc;
26595 PyObject *argv[3];
26596 int ii;
26597
26598 argc = PyObject_Length(args);
26599 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26600 argv[ii] = PyTuple_GetItem(args,ii);
26601 }
26602 if (argc == 2) {
26603 int _v;
26604 {
26605 void *ptr;
26606 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26607 _v = 0;
26608 PyErr_Clear();
26609 } else {
26610 _v = 1;
26611 }
26612 }
26613 if (_v) {
26614 {
26615 void *ptr = 0;
26616 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26617 _v = 0;
26618 PyErr_Clear();
26619 } else {
26620 _v = (ptr != 0);
26621 }
26622 }
26623 if (_v) {
26624 return _wrap_DataFormat___eq____SWIG_1(self,args);
26625 }
26626 }
26627 }
26628 if (argc == 2) {
26629 int _v;
26630 {
26631 void *ptr;
26632 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26633 _v = 0;
26634 PyErr_Clear();
26635 } else {
26636 _v = 1;
26637 }
26638 }
26639 if (_v) {
26640 _v = SWIG_Check_int(argv[1]);
26641 if (_v) {
26642 return _wrap_DataFormat___eq____SWIG_0(self,args);
26643 }
26644 }
26645 }
26646
26647 Py_INCREF(Py_NotImplemented);
26648 return Py_NotImplemented;
26649 }
26650
26651
26652 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26653 PyObject *resultobj;
26654 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26655 wxDataFormat *arg2 = 0 ;
26656 bool result;
26657 PyObject * obj0 = 0 ;
26658 PyObject * obj1 = 0 ;
26659
26660 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26662 if (SWIG_arg_fail(1)) SWIG_fail;
26663 {
26664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26665 if (SWIG_arg_fail(2)) SWIG_fail;
26666 if (arg2 == NULL) {
26667 SWIG_null_ref("wxDataFormat");
26668 }
26669 if (SWIG_arg_fail(2)) SWIG_fail;
26670 }
26671 {
26672 PyThreadState* __tstate = wxPyBeginAllowThreads();
26673 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26674
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 {
26679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26680 }
26681 return resultobj;
26682 fail:
26683 return NULL;
26684 }
26685
26686
26687 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26688 int argc;
26689 PyObject *argv[3];
26690 int ii;
26691
26692 argc = PyObject_Length(args);
26693 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26694 argv[ii] = PyTuple_GetItem(args,ii);
26695 }
26696 if (argc == 2) {
26697 int _v;
26698 {
26699 void *ptr;
26700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26701 _v = 0;
26702 PyErr_Clear();
26703 } else {
26704 _v = 1;
26705 }
26706 }
26707 if (_v) {
26708 {
26709 void *ptr = 0;
26710 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26711 _v = 0;
26712 PyErr_Clear();
26713 } else {
26714 _v = (ptr != 0);
26715 }
26716 }
26717 if (_v) {
26718 return _wrap_DataFormat___ne____SWIG_1(self,args);
26719 }
26720 }
26721 }
26722 if (argc == 2) {
26723 int _v;
26724 {
26725 void *ptr;
26726 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26727 _v = 0;
26728 PyErr_Clear();
26729 } else {
26730 _v = 1;
26731 }
26732 }
26733 if (_v) {
26734 _v = SWIG_Check_int(argv[1]);
26735 if (_v) {
26736 return _wrap_DataFormat___ne____SWIG_0(self,args);
26737 }
26738 }
26739 }
26740
26741 Py_INCREF(Py_NotImplemented);
26742 return Py_NotImplemented;
26743 }
26744
26745
26746 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26747 PyObject *resultobj;
26748 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26749 wxDataFormatId arg2 ;
26750 PyObject * obj0 = 0 ;
26751 PyObject * obj1 = 0 ;
26752 char *kwnames[] = {
26753 (char *) "self",(char *) "format", NULL
26754 };
26755
26756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26758 if (SWIG_arg_fail(1)) SWIG_fail;
26759 {
26760 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26761 if (SWIG_arg_fail(2)) SWIG_fail;
26762 }
26763 {
26764 PyThreadState* __tstate = wxPyBeginAllowThreads();
26765 (arg1)->SetType((wxDataFormatId )arg2);
26766
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 Py_INCREF(Py_None); resultobj = Py_None;
26771 return resultobj;
26772 fail:
26773 return NULL;
26774 }
26775
26776
26777 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26778 PyObject *resultobj;
26779 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26780 wxDataFormatId result;
26781 PyObject * obj0 = 0 ;
26782 char *kwnames[] = {
26783 (char *) "self", NULL
26784 };
26785
26786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26788 if (SWIG_arg_fail(1)) SWIG_fail;
26789 {
26790 PyThreadState* __tstate = wxPyBeginAllowThreads();
26791 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26792
26793 wxPyEndAllowThreads(__tstate);
26794 if (PyErr_Occurred()) SWIG_fail;
26795 }
26796 resultobj = SWIG_From_int((result));
26797 return resultobj;
26798 fail:
26799 return NULL;
26800 }
26801
26802
26803 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26804 PyObject *resultobj;
26805 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26806 wxString result;
26807 PyObject * obj0 = 0 ;
26808 char *kwnames[] = {
26809 (char *) "self", NULL
26810 };
26811
26812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26814 if (SWIG_arg_fail(1)) SWIG_fail;
26815 {
26816 PyThreadState* __tstate = wxPyBeginAllowThreads();
26817 result = ((wxDataFormat const *)arg1)->GetId();
26818
26819 wxPyEndAllowThreads(__tstate);
26820 if (PyErr_Occurred()) SWIG_fail;
26821 }
26822 {
26823 #if wxUSE_UNICODE
26824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26825 #else
26826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26827 #endif
26828 }
26829 return resultobj;
26830 fail:
26831 return NULL;
26832 }
26833
26834
26835 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26836 PyObject *resultobj;
26837 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26838 wxString *arg2 = 0 ;
26839 bool temp2 = false ;
26840 PyObject * obj0 = 0 ;
26841 PyObject * obj1 = 0 ;
26842 char *kwnames[] = {
26843 (char *) "self",(char *) "format", NULL
26844 };
26845
26846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26848 if (SWIG_arg_fail(1)) SWIG_fail;
26849 {
26850 arg2 = wxString_in_helper(obj1);
26851 if (arg2 == NULL) SWIG_fail;
26852 temp2 = true;
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 (arg1)->SetId((wxString const &)*arg2);
26857
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 Py_INCREF(Py_None); resultobj = Py_None;
26862 {
26863 if (temp2)
26864 delete arg2;
26865 }
26866 return resultobj;
26867 fail:
26868 {
26869 if (temp2)
26870 delete arg2;
26871 }
26872 return NULL;
26873 }
26874
26875
26876 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26877 PyObject *obj;
26878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26879 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26880 Py_INCREF(obj);
26881 return Py_BuildValue((char *)"");
26882 }
26883 static int _wrap_FormatInvalid_set(PyObject *) {
26884 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26885 return 1;
26886 }
26887
26888
26889 static PyObject *_wrap_FormatInvalid_get(void) {
26890 PyObject *pyobj;
26891
26892 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26893 return pyobj;
26894 }
26895
26896
26897 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26898 PyObject *resultobj;
26899 wxDataObject *arg1 = (wxDataObject *) 0 ;
26900 PyObject * obj0 = 0 ;
26901 char *kwnames[] = {
26902 (char *) "self", NULL
26903 };
26904
26905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26907 if (SWIG_arg_fail(1)) SWIG_fail;
26908 {
26909 PyThreadState* __tstate = wxPyBeginAllowThreads();
26910 delete arg1;
26911
26912 wxPyEndAllowThreads(__tstate);
26913 if (PyErr_Occurred()) SWIG_fail;
26914 }
26915 Py_INCREF(Py_None); resultobj = Py_None;
26916 return resultobj;
26917 fail:
26918 return NULL;
26919 }
26920
26921
26922 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26923 PyObject *resultobj;
26924 wxDataObject *arg1 = (wxDataObject *) 0 ;
26925 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26926 SwigValueWrapper<wxDataFormat > result;
26927 PyObject * obj0 = 0 ;
26928 PyObject * obj1 = 0 ;
26929 char *kwnames[] = {
26930 (char *) "self",(char *) "dir", NULL
26931 };
26932
26933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26935 if (SWIG_arg_fail(1)) SWIG_fail;
26936 if (obj1) {
26937 {
26938 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26939 if (SWIG_arg_fail(2)) SWIG_fail;
26940 }
26941 }
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26945
26946 wxPyEndAllowThreads(__tstate);
26947 if (PyErr_Occurred()) SWIG_fail;
26948 }
26949 {
26950 wxDataFormat * resultptr;
26951 resultptr = new wxDataFormat((wxDataFormat &)(result));
26952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26953 }
26954 return resultobj;
26955 fail:
26956 return NULL;
26957 }
26958
26959
26960 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26961 PyObject *resultobj;
26962 wxDataObject *arg1 = (wxDataObject *) 0 ;
26963 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26964 size_t result;
26965 PyObject * obj0 = 0 ;
26966 PyObject * obj1 = 0 ;
26967 char *kwnames[] = {
26968 (char *) "self",(char *) "dir", NULL
26969 };
26970
26971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26973 if (SWIG_arg_fail(1)) SWIG_fail;
26974 if (obj1) {
26975 {
26976 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26977 if (SWIG_arg_fail(2)) SWIG_fail;
26978 }
26979 }
26980 {
26981 PyThreadState* __tstate = wxPyBeginAllowThreads();
26982 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26983
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 {
26988 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26989 }
26990 return resultobj;
26991 fail:
26992 return NULL;
26993 }
26994
26995
26996 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26997 PyObject *resultobj;
26998 wxDataObject *arg1 = (wxDataObject *) 0 ;
26999 wxDataFormat *arg2 = 0 ;
27000 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27001 bool result;
27002 PyObject * obj0 = 0 ;
27003 PyObject * obj1 = 0 ;
27004 PyObject * obj2 = 0 ;
27005 char *kwnames[] = {
27006 (char *) "self",(char *) "format",(char *) "dir", NULL
27007 };
27008
27009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27011 if (SWIG_arg_fail(1)) SWIG_fail;
27012 {
27013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27014 if (SWIG_arg_fail(2)) SWIG_fail;
27015 if (arg2 == NULL) {
27016 SWIG_null_ref("wxDataFormat");
27017 }
27018 if (SWIG_arg_fail(2)) SWIG_fail;
27019 }
27020 if (obj2) {
27021 {
27022 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27023 if (SWIG_arg_fail(3)) SWIG_fail;
27024 }
27025 }
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27029
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 {
27034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27035 }
27036 return resultobj;
27037 fail:
27038 return NULL;
27039 }
27040
27041
27042 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27043 PyObject *resultobj;
27044 wxDataObject *arg1 = (wxDataObject *) 0 ;
27045 wxDataFormat *arg2 = 0 ;
27046 size_t result;
27047 PyObject * obj0 = 0 ;
27048 PyObject * obj1 = 0 ;
27049 char *kwnames[] = {
27050 (char *) "self",(char *) "format", NULL
27051 };
27052
27053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27055 if (SWIG_arg_fail(1)) SWIG_fail;
27056 {
27057 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27058 if (SWIG_arg_fail(2)) SWIG_fail;
27059 if (arg2 == NULL) {
27060 SWIG_null_ref("wxDataFormat");
27061 }
27062 if (SWIG_arg_fail(2)) SWIG_fail;
27063 }
27064 {
27065 PyThreadState* __tstate = wxPyBeginAllowThreads();
27066 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27067
27068 wxPyEndAllowThreads(__tstate);
27069 if (PyErr_Occurred()) SWIG_fail;
27070 }
27071 {
27072 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27073 }
27074 return resultobj;
27075 fail:
27076 return NULL;
27077 }
27078
27079
27080 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27081 PyObject *resultobj;
27082 wxDataObject *arg1 = (wxDataObject *) 0 ;
27083 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27084 PyObject *result;
27085 PyObject * obj0 = 0 ;
27086 PyObject * obj1 = 0 ;
27087 char *kwnames[] = {
27088 (char *) "self",(char *) "dir", NULL
27089 };
27090
27091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27093 if (SWIG_arg_fail(1)) SWIG_fail;
27094 if (obj1) {
27095 {
27096 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27097 if (SWIG_arg_fail(2)) SWIG_fail;
27098 }
27099 }
27100 {
27101 PyThreadState* __tstate = wxPyBeginAllowThreads();
27102 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27103
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 resultobj = result;
27108 return resultobj;
27109 fail:
27110 return NULL;
27111 }
27112
27113
27114 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27115 PyObject *resultobj;
27116 wxDataObject *arg1 = (wxDataObject *) 0 ;
27117 wxDataFormat *arg2 = 0 ;
27118 PyObject *result;
27119 PyObject * obj0 = 0 ;
27120 PyObject * obj1 = 0 ;
27121 char *kwnames[] = {
27122 (char *) "self",(char *) "format", NULL
27123 };
27124
27125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27127 if (SWIG_arg_fail(1)) SWIG_fail;
27128 {
27129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27130 if (SWIG_arg_fail(2)) SWIG_fail;
27131 if (arg2 == NULL) {
27132 SWIG_null_ref("wxDataFormat");
27133 }
27134 if (SWIG_arg_fail(2)) SWIG_fail;
27135 }
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 resultobj = result;
27144 return resultobj;
27145 fail:
27146 return NULL;
27147 }
27148
27149
27150 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj;
27152 wxDataObject *arg1 = (wxDataObject *) 0 ;
27153 wxDataFormat *arg2 = 0 ;
27154 PyObject *arg3 = (PyObject *) 0 ;
27155 bool result;
27156 PyObject * obj0 = 0 ;
27157 PyObject * obj1 = 0 ;
27158 PyObject * obj2 = 0 ;
27159 char *kwnames[] = {
27160 (char *) "self",(char *) "format",(char *) "data", NULL
27161 };
27162
27163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27165 if (SWIG_arg_fail(1)) SWIG_fail;
27166 {
27167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27168 if (SWIG_arg_fail(2)) SWIG_fail;
27169 if (arg2 == NULL) {
27170 SWIG_null_ref("wxDataFormat");
27171 }
27172 if (SWIG_arg_fail(2)) SWIG_fail;
27173 }
27174 arg3 = obj2;
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27178
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 {
27183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27184 }
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27192 PyObject *obj;
27193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27194 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27195 Py_INCREF(obj);
27196 return Py_BuildValue((char *)"");
27197 }
27198 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27199 PyObject *resultobj;
27200 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27201 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27202 wxDataObjectSimple *result;
27203 PyObject * obj0 = 0 ;
27204 char *kwnames[] = {
27205 (char *) "format", NULL
27206 };
27207
27208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27209 if (obj0) {
27210 {
27211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27212 if (SWIG_arg_fail(1)) SWIG_fail;
27213 if (arg1 == NULL) {
27214 SWIG_null_ref("wxDataFormat");
27215 }
27216 if (SWIG_arg_fail(1)) SWIG_fail;
27217 }
27218 }
27219 {
27220 PyThreadState* __tstate = wxPyBeginAllowThreads();
27221 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27222
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27234 PyObject *resultobj;
27235 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27236 wxDataFormat *result;
27237 PyObject * obj0 = 0 ;
27238 char *kwnames[] = {
27239 (char *) "self", NULL
27240 };
27241
27242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27244 if (SWIG_arg_fail(1)) SWIG_fail;
27245 {
27246 PyThreadState* __tstate = wxPyBeginAllowThreads();
27247 {
27248 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27249 result = (wxDataFormat *) &_result_ref;
27250 }
27251
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj;
27264 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27265 wxDataFormat *arg2 = 0 ;
27266 PyObject * obj0 = 0 ;
27267 PyObject * obj1 = 0 ;
27268 char *kwnames[] = {
27269 (char *) "self",(char *) "format", NULL
27270 };
27271
27272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27274 if (SWIG_arg_fail(1)) SWIG_fail;
27275 {
27276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27277 if (SWIG_arg_fail(2)) SWIG_fail;
27278 if (arg2 == NULL) {
27279 SWIG_null_ref("wxDataFormat");
27280 }
27281 if (SWIG_arg_fail(2)) SWIG_fail;
27282 }
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27286
27287 wxPyEndAllowThreads(__tstate);
27288 if (PyErr_Occurred()) SWIG_fail;
27289 }
27290 Py_INCREF(Py_None); resultobj = Py_None;
27291 return resultobj;
27292 fail:
27293 return NULL;
27294 }
27295
27296
27297 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27298 PyObject *resultobj;
27299 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27300 size_t result;
27301 PyObject * obj0 = 0 ;
27302 char *kwnames[] = {
27303 (char *) "self", NULL
27304 };
27305
27306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27308 if (SWIG_arg_fail(1)) SWIG_fail;
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27312
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 {
27317 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27318 }
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27326 PyObject *resultobj;
27327 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27328 PyObject *result;
27329 PyObject * obj0 = 0 ;
27330 char *kwnames[] = {
27331 (char *) "self", NULL
27332 };
27333
27334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27336 if (SWIG_arg_fail(1)) SWIG_fail;
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27340
27341 wxPyEndAllowThreads(__tstate);
27342 if (PyErr_Occurred()) SWIG_fail;
27343 }
27344 resultobj = result;
27345 return resultobj;
27346 fail:
27347 return NULL;
27348 }
27349
27350
27351 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27352 PyObject *resultobj;
27353 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27354 PyObject *arg2 = (PyObject *) 0 ;
27355 bool result;
27356 PyObject * obj0 = 0 ;
27357 PyObject * obj1 = 0 ;
27358 char *kwnames[] = {
27359 (char *) "self",(char *) "data", NULL
27360 };
27361
27362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27364 if (SWIG_arg_fail(1)) SWIG_fail;
27365 arg2 = obj1;
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27369
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27383 PyObject *obj;
27384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27385 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27386 Py_INCREF(obj);
27387 return Py_BuildValue((char *)"");
27388 }
27389 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj;
27391 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27392 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27393 wxPyDataObjectSimple *result;
27394 PyObject * obj0 = 0 ;
27395 char *kwnames[] = {
27396 (char *) "format", NULL
27397 };
27398
27399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27400 if (obj0) {
27401 {
27402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27403 if (SWIG_arg_fail(1)) SWIG_fail;
27404 if (arg1 == NULL) {
27405 SWIG_null_ref("wxDataFormat");
27406 }
27407 if (SWIG_arg_fail(1)) SWIG_fail;
27408 }
27409 }
27410 {
27411 PyThreadState* __tstate = wxPyBeginAllowThreads();
27412 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27413
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27418 return resultobj;
27419 fail:
27420 return NULL;
27421 }
27422
27423
27424 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27425 PyObject *resultobj;
27426 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27427 PyObject *arg2 = (PyObject *) 0 ;
27428 PyObject *arg3 = (PyObject *) 0 ;
27429 PyObject * obj0 = 0 ;
27430 PyObject * obj1 = 0 ;
27431 PyObject * obj2 = 0 ;
27432 char *kwnames[] = {
27433 (char *) "self",(char *) "self",(char *) "_class", NULL
27434 };
27435
27436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27438 if (SWIG_arg_fail(1)) SWIG_fail;
27439 arg2 = obj1;
27440 arg3 = obj2;
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 (arg1)->_setCallbackInfo(arg2,arg3);
27444
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 Py_INCREF(Py_None); resultobj = Py_None;
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27456 PyObject *obj;
27457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27458 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27459 Py_INCREF(obj);
27460 return Py_BuildValue((char *)"");
27461 }
27462 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27463 PyObject *resultobj;
27464 wxDataObjectComposite *result;
27465 char *kwnames[] = {
27466 NULL
27467 };
27468
27469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27473
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27485 PyObject *resultobj;
27486 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27487 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27488 bool arg3 = (bool) false ;
27489 PyObject * obj0 = 0 ;
27490 PyObject * obj1 = 0 ;
27491 PyObject * obj2 = 0 ;
27492 char *kwnames[] = {
27493 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27494 };
27495
27496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27498 if (SWIG_arg_fail(1)) SWIG_fail;
27499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27500 if (SWIG_arg_fail(2)) SWIG_fail;
27501 if (obj2) {
27502 {
27503 arg3 = (bool)(SWIG_As_bool(obj2));
27504 if (SWIG_arg_fail(3)) SWIG_fail;
27505 }
27506 }
27507 {
27508 PyThreadState* __tstate = wxPyBeginAllowThreads();
27509 (arg1)->Add(arg2,arg3);
27510
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 Py_INCREF(Py_None); resultobj = Py_None;
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27522 PyObject *obj;
27523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27524 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27525 Py_INCREF(obj);
27526 return Py_BuildValue((char *)"");
27527 }
27528 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj;
27530 wxString const &arg1_defvalue = wxPyEmptyString ;
27531 wxString *arg1 = (wxString *) &arg1_defvalue ;
27532 wxTextDataObject *result;
27533 bool temp1 = false ;
27534 PyObject * obj0 = 0 ;
27535 char *kwnames[] = {
27536 (char *) "text", NULL
27537 };
27538
27539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27540 if (obj0) {
27541 {
27542 arg1 = wxString_in_helper(obj0);
27543 if (arg1 == NULL) SWIG_fail;
27544 temp1 = true;
27545 }
27546 }
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27550
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27555 {
27556 if (temp1)
27557 delete arg1;
27558 }
27559 return resultobj;
27560 fail:
27561 {
27562 if (temp1)
27563 delete arg1;
27564 }
27565 return NULL;
27566 }
27567
27568
27569 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27570 PyObject *resultobj;
27571 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27572 size_t result;
27573 PyObject * obj0 = 0 ;
27574 char *kwnames[] = {
27575 (char *) "self", NULL
27576 };
27577
27578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27580 if (SWIG_arg_fail(1)) SWIG_fail;
27581 {
27582 PyThreadState* __tstate = wxPyBeginAllowThreads();
27583 result = (size_t)(arg1)->GetTextLength();
27584
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 {
27589 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27590 }
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27598 PyObject *resultobj;
27599 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27600 wxString result;
27601 PyObject * obj0 = 0 ;
27602 char *kwnames[] = {
27603 (char *) "self", NULL
27604 };
27605
27606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27608 if (SWIG_arg_fail(1)) SWIG_fail;
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 result = (arg1)->GetText();
27612
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 {
27617 #if wxUSE_UNICODE
27618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27619 #else
27620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27621 #endif
27622 }
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27632 wxString *arg2 = 0 ;
27633 bool temp2 = false ;
27634 PyObject * obj0 = 0 ;
27635 PyObject * obj1 = 0 ;
27636 char *kwnames[] = {
27637 (char *) "self",(char *) "text", NULL
27638 };
27639
27640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27642 if (SWIG_arg_fail(1)) SWIG_fail;
27643 {
27644 arg2 = wxString_in_helper(obj1);
27645 if (arg2 == NULL) SWIG_fail;
27646 temp2 = true;
27647 }
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 (arg1)->SetText((wxString const &)*arg2);
27651
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 Py_INCREF(Py_None); resultobj = Py_None;
27656 {
27657 if (temp2)
27658 delete arg2;
27659 }
27660 return resultobj;
27661 fail:
27662 {
27663 if (temp2)
27664 delete arg2;
27665 }
27666 return NULL;
27667 }
27668
27669
27670 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27671 PyObject *obj;
27672 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27673 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27674 Py_INCREF(obj);
27675 return Py_BuildValue((char *)"");
27676 }
27677 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27678 PyObject *resultobj;
27679 wxString const &arg1_defvalue = wxPyEmptyString ;
27680 wxString *arg1 = (wxString *) &arg1_defvalue ;
27681 wxPyTextDataObject *result;
27682 bool temp1 = false ;
27683 PyObject * obj0 = 0 ;
27684 char *kwnames[] = {
27685 (char *) "text", NULL
27686 };
27687
27688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27689 if (obj0) {
27690 {
27691 arg1 = wxString_in_helper(obj0);
27692 if (arg1 == NULL) SWIG_fail;
27693 temp1 = true;
27694 }
27695 }
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27699
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27704 {
27705 if (temp1)
27706 delete arg1;
27707 }
27708 return resultobj;
27709 fail:
27710 {
27711 if (temp1)
27712 delete arg1;
27713 }
27714 return NULL;
27715 }
27716
27717
27718 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27719 PyObject *resultobj;
27720 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27721 PyObject *arg2 = (PyObject *) 0 ;
27722 PyObject *arg3 = (PyObject *) 0 ;
27723 PyObject * obj0 = 0 ;
27724 PyObject * obj1 = 0 ;
27725 PyObject * obj2 = 0 ;
27726 char *kwnames[] = {
27727 (char *) "self",(char *) "self",(char *) "_class", NULL
27728 };
27729
27730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27732 if (SWIG_arg_fail(1)) SWIG_fail;
27733 arg2 = obj1;
27734 arg3 = obj2;
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 (arg1)->_setCallbackInfo(arg2,arg3);
27738
27739 wxPyEndAllowThreads(__tstate);
27740 if (PyErr_Occurred()) SWIG_fail;
27741 }
27742 Py_INCREF(Py_None); resultobj = Py_None;
27743 return resultobj;
27744 fail:
27745 return NULL;
27746 }
27747
27748
27749 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27750 PyObject *obj;
27751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27752 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27753 Py_INCREF(obj);
27754 return Py_BuildValue((char *)"");
27755 }
27756 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27757 PyObject *resultobj;
27758 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27759 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27760 wxBitmapDataObject *result;
27761 PyObject * obj0 = 0 ;
27762 char *kwnames[] = {
27763 (char *) "bitmap", NULL
27764 };
27765
27766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27767 if (obj0) {
27768 {
27769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27770 if (SWIG_arg_fail(1)) SWIG_fail;
27771 if (arg1 == NULL) {
27772 SWIG_null_ref("wxBitmap");
27773 }
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 }
27776 }
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27780
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27792 PyObject *resultobj;
27793 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27794 wxBitmap result;
27795 PyObject * obj0 = 0 ;
27796 char *kwnames[] = {
27797 (char *) "self", NULL
27798 };
27799
27800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27802 if (SWIG_arg_fail(1)) SWIG_fail;
27803 {
27804 PyThreadState* __tstate = wxPyBeginAllowThreads();
27805 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27806
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 {
27811 wxBitmap * resultptr;
27812 resultptr = new wxBitmap((wxBitmap &)(result));
27813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27814 }
27815 return resultobj;
27816 fail:
27817 return NULL;
27818 }
27819
27820
27821 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27822 PyObject *resultobj;
27823 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27824 wxBitmap *arg2 = 0 ;
27825 PyObject * obj0 = 0 ;
27826 PyObject * obj1 = 0 ;
27827 char *kwnames[] = {
27828 (char *) "self",(char *) "bitmap", NULL
27829 };
27830
27831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27833 if (SWIG_arg_fail(1)) SWIG_fail;
27834 {
27835 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27836 if (SWIG_arg_fail(2)) SWIG_fail;
27837 if (arg2 == NULL) {
27838 SWIG_null_ref("wxBitmap");
27839 }
27840 if (SWIG_arg_fail(2)) SWIG_fail;
27841 }
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 Py_INCREF(Py_None); resultobj = Py_None;
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27857 PyObject *obj;
27858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27859 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27860 Py_INCREF(obj);
27861 return Py_BuildValue((char *)"");
27862 }
27863 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27864 PyObject *resultobj;
27865 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27866 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27867 wxPyBitmapDataObject *result;
27868 PyObject * obj0 = 0 ;
27869 char *kwnames[] = {
27870 (char *) "bitmap", NULL
27871 };
27872
27873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27874 if (obj0) {
27875 {
27876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27877 if (SWIG_arg_fail(1)) SWIG_fail;
27878 if (arg1 == NULL) {
27879 SWIG_null_ref("wxBitmap");
27880 }
27881 if (SWIG_arg_fail(1)) SWIG_fail;
27882 }
27883 }
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27887
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj;
27900 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27901 PyObject *arg2 = (PyObject *) 0 ;
27902 PyObject *arg3 = (PyObject *) 0 ;
27903 PyObject * obj0 = 0 ;
27904 PyObject * obj1 = 0 ;
27905 PyObject * obj2 = 0 ;
27906 char *kwnames[] = {
27907 (char *) "self",(char *) "self",(char *) "_class", NULL
27908 };
27909
27910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27912 if (SWIG_arg_fail(1)) SWIG_fail;
27913 arg2 = obj1;
27914 arg3 = obj2;
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 (arg1)->_setCallbackInfo(arg2,arg3);
27918
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 Py_INCREF(Py_None); resultobj = Py_None;
27923 return resultobj;
27924 fail:
27925 return NULL;
27926 }
27927
27928
27929 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27930 PyObject *obj;
27931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27932 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27933 Py_INCREF(obj);
27934 return Py_BuildValue((char *)"");
27935 }
27936 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27937 PyObject *resultobj;
27938 wxFileDataObject *result;
27939 char *kwnames[] = {
27940 NULL
27941 };
27942
27943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (wxFileDataObject *)new wxFileDataObject();
27947
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27959 PyObject *resultobj;
27960 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27961 wxArrayString *result;
27962 PyObject * obj0 = 0 ;
27963 char *kwnames[] = {
27964 (char *) "self", NULL
27965 };
27966
27967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(1)) SWIG_fail;
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 {
27973 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27974 result = (wxArrayString *) &_result_ref;
27975 }
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = wxArrayString2PyList_helper(*result);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27992 wxString *arg2 = 0 ;
27993 bool temp2 = false ;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char *kwnames[] = {
27997 (char *) "self",(char *) "filename", NULL
27998 };
27999
28000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28002 if (SWIG_arg_fail(1)) SWIG_fail;
28003 {
28004 arg2 = wxString_in_helper(obj1);
28005 if (arg2 == NULL) SWIG_fail;
28006 temp2 = true;
28007 }
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->AddFile((wxString const &)*arg2);
28011
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 Py_INCREF(Py_None); resultobj = Py_None;
28016 {
28017 if (temp2)
28018 delete arg2;
28019 }
28020 return resultobj;
28021 fail:
28022 {
28023 if (temp2)
28024 delete arg2;
28025 }
28026 return NULL;
28027 }
28028
28029
28030 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28031 PyObject *obj;
28032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28033 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28034 Py_INCREF(obj);
28035 return Py_BuildValue((char *)"");
28036 }
28037 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28038 PyObject *resultobj;
28039 wxDataFormat *arg1 = 0 ;
28040 wxCustomDataObject *result;
28041 PyObject * obj0 = 0 ;
28042
28043 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28044 {
28045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28046 if (SWIG_arg_fail(1)) SWIG_fail;
28047 if (arg1 == NULL) {
28048 SWIG_null_ref("wxDataFormat");
28049 }
28050 if (SWIG_arg_fail(1)) SWIG_fail;
28051 }
28052 {
28053 PyThreadState* __tstate = wxPyBeginAllowThreads();
28054 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28055
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28060 return resultobj;
28061 fail:
28062 return NULL;
28063 }
28064
28065
28066 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28067 PyObject *resultobj;
28068 wxString *arg1 = 0 ;
28069 wxCustomDataObject *result;
28070 bool temp1 = false ;
28071 PyObject * obj0 = 0 ;
28072
28073 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28074 {
28075 arg1 = wxString_in_helper(obj0);
28076 if (arg1 == NULL) SWIG_fail;
28077 temp1 = true;
28078 }
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28082
28083 wxPyEndAllowThreads(__tstate);
28084 if (PyErr_Occurred()) SWIG_fail;
28085 }
28086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28087 {
28088 if (temp1)
28089 delete arg1;
28090 }
28091 return resultobj;
28092 fail:
28093 {
28094 if (temp1)
28095 delete arg1;
28096 }
28097 return NULL;
28098 }
28099
28100
28101 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28102 PyObject *resultobj;
28103 wxCustomDataObject *result;
28104
28105 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (wxCustomDataObject *)new wxCustomDataObject();
28109
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28121 int argc;
28122 PyObject *argv[2];
28123 int ii;
28124
28125 argc = PyObject_Length(args);
28126 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28127 argv[ii] = PyTuple_GetItem(args,ii);
28128 }
28129 if (argc == 0) {
28130 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28131 }
28132 if (argc == 1) {
28133 int _v;
28134 {
28135 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28136 }
28137 if (_v) {
28138 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28139 }
28140 }
28141 if (argc == 1) {
28142 int _v;
28143 {
28144 void *ptr = 0;
28145 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28146 _v = 0;
28147 PyErr_Clear();
28148 } else {
28149 _v = (ptr != 0);
28150 }
28151 }
28152 if (_v) {
28153 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28154 }
28155 }
28156
28157 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28158 return NULL;
28159 }
28160
28161
28162 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28163 PyObject *resultobj;
28164 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28165 PyObject *arg2 = (PyObject *) 0 ;
28166 bool result;
28167 PyObject * obj0 = 0 ;
28168 PyObject * obj1 = 0 ;
28169 char *kwnames[] = {
28170 (char *) "self",(char *) "data", NULL
28171 };
28172
28173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28175 if (SWIG_arg_fail(1)) SWIG_fail;
28176 arg2 = obj1;
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28180
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 {
28185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28186 }
28187 return resultobj;
28188 fail:
28189 return NULL;
28190 }
28191
28192
28193 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28194 PyObject *resultobj;
28195 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28196 size_t result;
28197 PyObject * obj0 = 0 ;
28198 char *kwnames[] = {
28199 (char *) "self", NULL
28200 };
28201
28202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28204 if (SWIG_arg_fail(1)) SWIG_fail;
28205 {
28206 PyThreadState* __tstate = wxPyBeginAllowThreads();
28207 result = (size_t)(arg1)->GetSize();
28208
28209 wxPyEndAllowThreads(__tstate);
28210 if (PyErr_Occurred()) SWIG_fail;
28211 }
28212 {
28213 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28214 }
28215 return resultobj;
28216 fail:
28217 return NULL;
28218 }
28219
28220
28221 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28222 PyObject *resultobj;
28223 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28224 PyObject *result;
28225 PyObject * obj0 = 0 ;
28226 char *kwnames[] = {
28227 (char *) "self", NULL
28228 };
28229
28230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28232 if (SWIG_arg_fail(1)) SWIG_fail;
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28236
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = result;
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28248 PyObject *obj;
28249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28250 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28251 Py_INCREF(obj);
28252 return Py_BuildValue((char *)"");
28253 }
28254 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxURLDataObject *result;
28257 char *kwnames[] = {
28258 NULL
28259 };
28260
28261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (wxURLDataObject *)new wxURLDataObject();
28265
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj;
28278 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28279 wxString result;
28280 PyObject * obj0 = 0 ;
28281 char *kwnames[] = {
28282 (char *) "self", NULL
28283 };
28284
28285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(1)) SWIG_fail;
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 result = (arg1)->GetURL();
28291
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 {
28296 #if wxUSE_UNICODE
28297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28298 #else
28299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28300 #endif
28301 }
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28309 PyObject *resultobj;
28310 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28311 wxString *arg2 = 0 ;
28312 bool temp2 = false ;
28313 PyObject * obj0 = 0 ;
28314 PyObject * obj1 = 0 ;
28315 char *kwnames[] = {
28316 (char *) "self",(char *) "url", NULL
28317 };
28318
28319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28321 if (SWIG_arg_fail(1)) SWIG_fail;
28322 {
28323 arg2 = wxString_in_helper(obj1);
28324 if (arg2 == NULL) SWIG_fail;
28325 temp2 = true;
28326 }
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 (arg1)->SetURL((wxString const &)*arg2);
28330
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 Py_INCREF(Py_None); resultobj = Py_None;
28335 {
28336 if (temp2)
28337 delete arg2;
28338 }
28339 return resultobj;
28340 fail:
28341 {
28342 if (temp2)
28343 delete arg2;
28344 }
28345 return NULL;
28346 }
28347
28348
28349 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28350 PyObject *obj;
28351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28352 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28353 Py_INCREF(obj);
28354 return Py_BuildValue((char *)"");
28355 }
28356 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28357 PyObject *resultobj;
28358 wxMetafileDataObject *result;
28359 char *kwnames[] = {
28360 NULL
28361 };
28362
28363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28367
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28381 wxMetafile *arg2 = 0 ;
28382 PyObject * obj0 = 0 ;
28383 PyObject * obj1 = 0 ;
28384 char *kwnames[] = {
28385 (char *) "self",(char *) "metafile", NULL
28386 };
28387
28388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28390 if (SWIG_arg_fail(1)) SWIG_fail;
28391 {
28392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(2)) SWIG_fail;
28394 if (arg2 == NULL) {
28395 SWIG_null_ref("wxMetafile");
28396 }
28397 if (SWIG_arg_fail(2)) SWIG_fail;
28398 }
28399 {
28400 PyThreadState* __tstate = wxPyBeginAllowThreads();
28401 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28402
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 Py_INCREF(Py_None); resultobj = Py_None;
28407 return resultobj;
28408 fail:
28409 return NULL;
28410 }
28411
28412
28413 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28414 PyObject *resultobj;
28415 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28416 wxMetafile result;
28417 PyObject * obj0 = 0 ;
28418 char *kwnames[] = {
28419 (char *) "self", NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28424 if (SWIG_arg_fail(1)) SWIG_fail;
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28428
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 {
28433 wxMetafile * resultptr;
28434 resultptr = new wxMetafile((wxMetafile &)(result));
28435 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28436 }
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28444 PyObject *obj;
28445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28446 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28447 Py_INCREF(obj);
28448 return Py_BuildValue((char *)"");
28449 }
28450 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28451 PyObject *resultobj;
28452 wxDragResult arg1 ;
28453 bool result;
28454 PyObject * obj0 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "res", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28460 {
28461 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28462 if (SWIG_arg_fail(1)) SWIG_fail;
28463 }
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28467
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 {
28472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28473 }
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28481 PyObject *resultobj;
28482 wxWindow *arg1 = (wxWindow *) 0 ;
28483 wxCursor const &arg2_defvalue = wxNullCursor ;
28484 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28485 wxCursor const &arg3_defvalue = wxNullCursor ;
28486 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28487 wxCursor const &arg4_defvalue = wxNullCursor ;
28488 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28489 wxPyDropSource *result;
28490 PyObject * obj0 = 0 ;
28491 PyObject * obj1 = 0 ;
28492 PyObject * obj2 = 0 ;
28493 PyObject * obj3 = 0 ;
28494 char *kwnames[] = {
28495 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28496 };
28497
28498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28500 if (SWIG_arg_fail(1)) SWIG_fail;
28501 if (obj1) {
28502 {
28503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28504 if (SWIG_arg_fail(2)) SWIG_fail;
28505 if (arg2 == NULL) {
28506 SWIG_null_ref("wxCursor");
28507 }
28508 if (SWIG_arg_fail(2)) SWIG_fail;
28509 }
28510 }
28511 if (obj2) {
28512 {
28513 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28514 if (SWIG_arg_fail(3)) SWIG_fail;
28515 if (arg3 == NULL) {
28516 SWIG_null_ref("wxCursor");
28517 }
28518 if (SWIG_arg_fail(3)) SWIG_fail;
28519 }
28520 }
28521 if (obj3) {
28522 {
28523 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28524 if (SWIG_arg_fail(4)) SWIG_fail;
28525 if (arg4 == NULL) {
28526 SWIG_null_ref("wxCursor");
28527 }
28528 if (SWIG_arg_fail(4)) SWIG_fail;
28529 }
28530 }
28531 {
28532 PyThreadState* __tstate = wxPyBeginAllowThreads();
28533 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28534
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28546 PyObject *resultobj;
28547 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28548 PyObject *arg2 = (PyObject *) 0 ;
28549 PyObject *arg3 = (PyObject *) 0 ;
28550 int arg4 ;
28551 PyObject * obj0 = 0 ;
28552 PyObject * obj1 = 0 ;
28553 PyObject * obj2 = 0 ;
28554 PyObject * obj3 = 0 ;
28555 char *kwnames[] = {
28556 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28557 };
28558
28559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28561 if (SWIG_arg_fail(1)) SWIG_fail;
28562 arg2 = obj1;
28563 arg3 = obj2;
28564 {
28565 arg4 = (int)(SWIG_As_int(obj3));
28566 if (SWIG_arg_fail(4)) SWIG_fail;
28567 }
28568 {
28569 PyThreadState* __tstate = wxPyBeginAllowThreads();
28570 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28571
28572 wxPyEndAllowThreads(__tstate);
28573 if (PyErr_Occurred()) SWIG_fail;
28574 }
28575 Py_INCREF(Py_None); resultobj = Py_None;
28576 return resultobj;
28577 fail:
28578 return NULL;
28579 }
28580
28581
28582 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj;
28584 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28585 PyObject * obj0 = 0 ;
28586 char *kwnames[] = {
28587 (char *) "self", NULL
28588 };
28589
28590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28592 if (SWIG_arg_fail(1)) SWIG_fail;
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 delete arg1;
28596
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 Py_INCREF(Py_None); resultobj = Py_None;
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28608 PyObject *resultobj;
28609 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28610 wxDataObject *arg2 = 0 ;
28611 PyObject * obj0 = 0 ;
28612 PyObject * obj1 = 0 ;
28613 char *kwnames[] = {
28614 (char *) "self",(char *) "data", NULL
28615 };
28616
28617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28619 if (SWIG_arg_fail(1)) SWIG_fail;
28620 {
28621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(2)) SWIG_fail;
28623 if (arg2 == NULL) {
28624 SWIG_null_ref("wxDataObject");
28625 }
28626 if (SWIG_arg_fail(2)) SWIG_fail;
28627 }
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 (arg1)->SetData(*arg2);
28631
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 Py_INCREF(Py_None); resultobj = Py_None;
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28645 wxDataObject *result;
28646 PyObject * obj0 = 0 ;
28647 char *kwnames[] = {
28648 (char *) "self", NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28653 if (SWIG_arg_fail(1)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (wxDataObject *)(arg1)->GetDataObject();
28657
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28662 return resultobj;
28663 fail:
28664 return NULL;
28665 }
28666
28667
28668 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28669 PyObject *resultobj;
28670 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28671 wxDragResult arg2 ;
28672 wxCursor *arg3 = 0 ;
28673 PyObject * obj0 = 0 ;
28674 PyObject * obj1 = 0 ;
28675 PyObject * obj2 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self",(char *) "res",(char *) "cursor", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28685 if (SWIG_arg_fail(2)) SWIG_fail;
28686 }
28687 {
28688 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28689 if (SWIG_arg_fail(3)) SWIG_fail;
28690 if (arg3 == NULL) {
28691 SWIG_null_ref("wxCursor");
28692 }
28693 if (SWIG_arg_fail(3)) SWIG_fail;
28694 }
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28698
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 Py_INCREF(Py_None); resultobj = Py_None;
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28710 PyObject *resultobj;
28711 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28712 int arg2 = (int) wxDrag_CopyOnly ;
28713 wxDragResult result;
28714 PyObject * obj0 = 0 ;
28715 PyObject * obj1 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "self",(char *) "flags", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 if (obj1) {
28724 {
28725 arg2 = (int)(SWIG_As_int(obj1));
28726 if (SWIG_arg_fail(2)) SWIG_fail;
28727 }
28728 }
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28732
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_From_int((result));
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28744 PyObject *resultobj;
28745 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28746 wxDragResult arg2 ;
28747 bool result;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 char *kwnames[] = {
28751 (char *) "self",(char *) "effect", NULL
28752 };
28753
28754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(1)) SWIG_fail;
28757 {
28758 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28759 if (SWIG_arg_fail(2)) SWIG_fail;
28760 }
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28764
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 {
28769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28770 }
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28778 PyObject *obj;
28779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28780 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28781 Py_INCREF(obj);
28782 return Py_BuildValue((char *)"");
28783 }
28784 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28785 PyObject *resultobj;
28786 wxDataObject *arg1 = (wxDataObject *) NULL ;
28787 wxPyDropTarget *result;
28788 PyObject * obj0 = 0 ;
28789 char *kwnames[] = {
28790 (char *) "dataObject", NULL
28791 };
28792
28793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28794 if (obj0) {
28795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28796 if (SWIG_arg_fail(1)) SWIG_fail;
28797 }
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj;
28814 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28815 PyObject *arg2 = (PyObject *) 0 ;
28816 PyObject *arg3 = (PyObject *) 0 ;
28817 PyObject * obj0 = 0 ;
28818 PyObject * obj1 = 0 ;
28819 PyObject * obj2 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self",(char *) "self",(char *) "_class", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28826 if (SWIG_arg_fail(1)) SWIG_fail;
28827 arg2 = obj1;
28828 arg3 = obj2;
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 (arg1)->_setCallbackInfo(arg2,arg3);
28832
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 Py_INCREF(Py_None); resultobj = Py_None;
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj;
28845 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28846 PyObject * obj0 = 0 ;
28847 char *kwnames[] = {
28848 (char *) "self", NULL
28849 };
28850
28851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28853 if (SWIG_arg_fail(1)) SWIG_fail;
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 delete arg1;
28857
28858 wxPyEndAllowThreads(__tstate);
28859 if (PyErr_Occurred()) SWIG_fail;
28860 }
28861 Py_INCREF(Py_None); resultobj = Py_None;
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28869 PyObject *resultobj;
28870 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28871 wxDataObject *result;
28872 PyObject * obj0 = 0 ;
28873 char *kwnames[] = {
28874 (char *) "self", NULL
28875 };
28876
28877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28879 if (SWIG_arg_fail(1)) SWIG_fail;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 result = (wxDataObject *)(arg1)->GetDataObject();
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28895 PyObject *resultobj;
28896 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28897 wxDataObject *arg2 = (wxDataObject *) 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char *kwnames[] = {
28901 (char *) "self",(char *) "dataObject", NULL
28902 };
28903
28904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28906 if (SWIG_arg_fail(1)) SWIG_fail;
28907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28908 if (SWIG_arg_fail(2)) SWIG_fail;
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 (arg1)->SetDataObject(arg2);
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 Py_INCREF(Py_None); resultobj = Py_None;
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28926 int arg2 ;
28927 int arg3 ;
28928 wxDragResult arg4 ;
28929 wxDragResult result;
28930 PyObject * obj0 = 0 ;
28931 PyObject * obj1 = 0 ;
28932 PyObject * obj2 = 0 ;
28933 PyObject * obj3 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 arg2 = (int)(SWIG_As_int(obj1));
28943 if (SWIG_arg_fail(2)) SWIG_fail;
28944 }
28945 {
28946 arg3 = (int)(SWIG_As_int(obj2));
28947 if (SWIG_arg_fail(3)) SWIG_fail;
28948 }
28949 {
28950 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28951 if (SWIG_arg_fail(4)) SWIG_fail;
28952 }
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28956
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_From_int((result));
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj;
28969 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28970 int arg2 ;
28971 int arg3 ;
28972 wxDragResult arg4 ;
28973 wxDragResult result;
28974 PyObject * obj0 = 0 ;
28975 PyObject * obj1 = 0 ;
28976 PyObject * obj2 = 0 ;
28977 PyObject * obj3 = 0 ;
28978 char *kwnames[] = {
28979 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28980 };
28981
28982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28984 if (SWIG_arg_fail(1)) SWIG_fail;
28985 {
28986 arg2 = (int)(SWIG_As_int(obj1));
28987 if (SWIG_arg_fail(2)) SWIG_fail;
28988 }
28989 {
28990 arg3 = (int)(SWIG_As_int(obj2));
28991 if (SWIG_arg_fail(3)) SWIG_fail;
28992 }
28993 {
28994 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28995 if (SWIG_arg_fail(4)) SWIG_fail;
28996 }
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29000
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 resultobj = SWIG_From_int((result));
29005 return resultobj;
29006 fail:
29007 return NULL;
29008 }
29009
29010
29011 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29012 PyObject *resultobj;
29013 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29014 PyObject * obj0 = 0 ;
29015 char *kwnames[] = {
29016 (char *) "self", NULL
29017 };
29018
29019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29021 if (SWIG_arg_fail(1)) SWIG_fail;
29022 {
29023 PyThreadState* __tstate = wxPyBeginAllowThreads();
29024 (arg1)->base_OnLeave();
29025
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 Py_INCREF(Py_None); resultobj = Py_None;
29030 return resultobj;
29031 fail:
29032 return NULL;
29033 }
29034
29035
29036 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29037 PyObject *resultobj;
29038 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29039 int arg2 ;
29040 int arg3 ;
29041 bool result;
29042 PyObject * obj0 = 0 ;
29043 PyObject * obj1 = 0 ;
29044 PyObject * obj2 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "x",(char *) "y", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 arg2 = (int)(SWIG_As_int(obj1));
29054 if (SWIG_arg_fail(2)) SWIG_fail;
29055 }
29056 {
29057 arg3 = (int)(SWIG_As_int(obj2));
29058 if (SWIG_arg_fail(3)) SWIG_fail;
29059 }
29060 {
29061 PyThreadState* __tstate = wxPyBeginAllowThreads();
29062 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29063
29064 wxPyEndAllowThreads(__tstate);
29065 if (PyErr_Occurred()) SWIG_fail;
29066 }
29067 {
29068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29069 }
29070 return resultobj;
29071 fail:
29072 return NULL;
29073 }
29074
29075
29076 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj;
29078 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29079 bool result;
29080 PyObject * obj0 = 0 ;
29081 char *kwnames[] = {
29082 (char *) "self", NULL
29083 };
29084
29085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29087 if (SWIG_arg_fail(1)) SWIG_fail;
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 result = (bool)(arg1)->GetData();
29091
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 {
29096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29097 }
29098 return resultobj;
29099 fail:
29100 return NULL;
29101 }
29102
29103
29104 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29105 PyObject *obj;
29106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29107 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29108 Py_INCREF(obj);
29109 return Py_BuildValue((char *)"");
29110 }
29111 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj;
29113 wxPyTextDropTarget *result;
29114 char *kwnames[] = {
29115 NULL
29116 };
29117
29118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29122
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj;
29135 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29136 PyObject *arg2 = (PyObject *) 0 ;
29137 PyObject *arg3 = (PyObject *) 0 ;
29138 PyObject * obj0 = 0 ;
29139 PyObject * obj1 = 0 ;
29140 PyObject * obj2 = 0 ;
29141 char *kwnames[] = {
29142 (char *) "self",(char *) "self",(char *) "_class", NULL
29143 };
29144
29145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29147 if (SWIG_arg_fail(1)) SWIG_fail;
29148 arg2 = obj1;
29149 arg3 = obj2;
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 (arg1)->_setCallbackInfo(arg2,arg3);
29153
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 Py_INCREF(Py_None); resultobj = Py_None;
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29165 PyObject *resultobj;
29166 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29167 int arg2 ;
29168 int arg3 ;
29169 wxDragResult arg4 ;
29170 wxDragResult result;
29171 PyObject * obj0 = 0 ;
29172 PyObject * obj1 = 0 ;
29173 PyObject * obj2 = 0 ;
29174 PyObject * obj3 = 0 ;
29175 char *kwnames[] = {
29176 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29177 };
29178
29179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29181 if (SWIG_arg_fail(1)) SWIG_fail;
29182 {
29183 arg2 = (int)(SWIG_As_int(obj1));
29184 if (SWIG_arg_fail(2)) SWIG_fail;
29185 }
29186 {
29187 arg3 = (int)(SWIG_As_int(obj2));
29188 if (SWIG_arg_fail(3)) SWIG_fail;
29189 }
29190 {
29191 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29192 if (SWIG_arg_fail(4)) SWIG_fail;
29193 }
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29197
29198 wxPyEndAllowThreads(__tstate);
29199 if (PyErr_Occurred()) SWIG_fail;
29200 }
29201 resultobj = SWIG_From_int((result));
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29209 PyObject *resultobj;
29210 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29211 int arg2 ;
29212 int arg3 ;
29213 wxDragResult arg4 ;
29214 wxDragResult result;
29215 PyObject * obj0 = 0 ;
29216 PyObject * obj1 = 0 ;
29217 PyObject * obj2 = 0 ;
29218 PyObject * obj3 = 0 ;
29219 char *kwnames[] = {
29220 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29221 };
29222
29223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29225 if (SWIG_arg_fail(1)) SWIG_fail;
29226 {
29227 arg2 = (int)(SWIG_As_int(obj1));
29228 if (SWIG_arg_fail(2)) SWIG_fail;
29229 }
29230 {
29231 arg3 = (int)(SWIG_As_int(obj2));
29232 if (SWIG_arg_fail(3)) SWIG_fail;
29233 }
29234 {
29235 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29236 if (SWIG_arg_fail(4)) SWIG_fail;
29237 }
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29241
29242 wxPyEndAllowThreads(__tstate);
29243 if (PyErr_Occurred()) SWIG_fail;
29244 }
29245 resultobj = SWIG_From_int((result));
29246 return resultobj;
29247 fail:
29248 return NULL;
29249 }
29250
29251
29252 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29253 PyObject *resultobj;
29254 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29255 PyObject * obj0 = 0 ;
29256 char *kwnames[] = {
29257 (char *) "self", NULL
29258 };
29259
29260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(1)) SWIG_fail;
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 (arg1)->base_OnLeave();
29266
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 Py_INCREF(Py_None); resultobj = Py_None;
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj;
29279 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29280 int arg2 ;
29281 int arg3 ;
29282 bool result;
29283 PyObject * obj0 = 0 ;
29284 PyObject * obj1 = 0 ;
29285 PyObject * obj2 = 0 ;
29286 char *kwnames[] = {
29287 (char *) "self",(char *) "x",(char *) "y", NULL
29288 };
29289
29290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29292 if (SWIG_arg_fail(1)) SWIG_fail;
29293 {
29294 arg2 = (int)(SWIG_As_int(obj1));
29295 if (SWIG_arg_fail(2)) SWIG_fail;
29296 }
29297 {
29298 arg3 = (int)(SWIG_As_int(obj2));
29299 if (SWIG_arg_fail(3)) SWIG_fail;
29300 }
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29304
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 {
29309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29310 }
29311 return resultobj;
29312 fail:
29313 return NULL;
29314 }
29315
29316
29317 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29318 PyObject *resultobj;
29319 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29320 int arg2 ;
29321 int arg3 ;
29322 wxDragResult arg4 ;
29323 wxDragResult result;
29324 PyObject * obj0 = 0 ;
29325 PyObject * obj1 = 0 ;
29326 PyObject * obj2 = 0 ;
29327 PyObject * obj3 = 0 ;
29328 char *kwnames[] = {
29329 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29330 };
29331
29332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29334 if (SWIG_arg_fail(1)) SWIG_fail;
29335 {
29336 arg2 = (int)(SWIG_As_int(obj1));
29337 if (SWIG_arg_fail(2)) SWIG_fail;
29338 }
29339 {
29340 arg3 = (int)(SWIG_As_int(obj2));
29341 if (SWIG_arg_fail(3)) SWIG_fail;
29342 }
29343 {
29344 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29345 if (SWIG_arg_fail(4)) SWIG_fail;
29346 }
29347 {
29348 PyThreadState* __tstate = wxPyBeginAllowThreads();
29349 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29350
29351 wxPyEndAllowThreads(__tstate);
29352 if (PyErr_Occurred()) SWIG_fail;
29353 }
29354 resultobj = SWIG_From_int((result));
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29362 PyObject *obj;
29363 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29364 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29365 Py_INCREF(obj);
29366 return Py_BuildValue((char *)"");
29367 }
29368 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29369 PyObject *resultobj;
29370 wxPyFileDropTarget *result;
29371 char *kwnames[] = {
29372 NULL
29373 };
29374
29375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj;
29392 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29393 PyObject *arg2 = (PyObject *) 0 ;
29394 PyObject *arg3 = (PyObject *) 0 ;
29395 PyObject * obj0 = 0 ;
29396 PyObject * obj1 = 0 ;
29397 PyObject * obj2 = 0 ;
29398 char *kwnames[] = {
29399 (char *) "self",(char *) "self",(char *) "_class", NULL
29400 };
29401
29402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29404 if (SWIG_arg_fail(1)) SWIG_fail;
29405 arg2 = obj1;
29406 arg3 = obj2;
29407 {
29408 PyThreadState* __tstate = wxPyBeginAllowThreads();
29409 (arg1)->_setCallbackInfo(arg2,arg3);
29410
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 Py_INCREF(Py_None); resultobj = Py_None;
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29422 PyObject *resultobj;
29423 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29424 int arg2 ;
29425 int arg3 ;
29426 wxDragResult arg4 ;
29427 wxDragResult result;
29428 PyObject * obj0 = 0 ;
29429 PyObject * obj1 = 0 ;
29430 PyObject * obj2 = 0 ;
29431 PyObject * obj3 = 0 ;
29432 char *kwnames[] = {
29433 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29434 };
29435
29436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29438 if (SWIG_arg_fail(1)) SWIG_fail;
29439 {
29440 arg2 = (int)(SWIG_As_int(obj1));
29441 if (SWIG_arg_fail(2)) SWIG_fail;
29442 }
29443 {
29444 arg3 = (int)(SWIG_As_int(obj2));
29445 if (SWIG_arg_fail(3)) SWIG_fail;
29446 }
29447 {
29448 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29449 if (SWIG_arg_fail(4)) SWIG_fail;
29450 }
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29454
29455 wxPyEndAllowThreads(__tstate);
29456 if (PyErr_Occurred()) SWIG_fail;
29457 }
29458 resultobj = SWIG_From_int((result));
29459 return resultobj;
29460 fail:
29461 return NULL;
29462 }
29463
29464
29465 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29466 PyObject *resultobj;
29467 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29468 int arg2 ;
29469 int arg3 ;
29470 wxDragResult arg4 ;
29471 wxDragResult result;
29472 PyObject * obj0 = 0 ;
29473 PyObject * obj1 = 0 ;
29474 PyObject * obj2 = 0 ;
29475 PyObject * obj3 = 0 ;
29476 char *kwnames[] = {
29477 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29478 };
29479
29480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29482 if (SWIG_arg_fail(1)) SWIG_fail;
29483 {
29484 arg2 = (int)(SWIG_As_int(obj1));
29485 if (SWIG_arg_fail(2)) SWIG_fail;
29486 }
29487 {
29488 arg3 = (int)(SWIG_As_int(obj2));
29489 if (SWIG_arg_fail(3)) SWIG_fail;
29490 }
29491 {
29492 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29493 if (SWIG_arg_fail(4)) SWIG_fail;
29494 }
29495 {
29496 PyThreadState* __tstate = wxPyBeginAllowThreads();
29497 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29498
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_From_int((result));
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29510 PyObject *resultobj;
29511 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29512 PyObject * obj0 = 0 ;
29513 char *kwnames[] = {
29514 (char *) "self", NULL
29515 };
29516
29517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29519 if (SWIG_arg_fail(1)) SWIG_fail;
29520 {
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 (arg1)->base_OnLeave();
29523
29524 wxPyEndAllowThreads(__tstate);
29525 if (PyErr_Occurred()) SWIG_fail;
29526 }
29527 Py_INCREF(Py_None); resultobj = Py_None;
29528 return resultobj;
29529 fail:
29530 return NULL;
29531 }
29532
29533
29534 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29535 PyObject *resultobj;
29536 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29537 int arg2 ;
29538 int arg3 ;
29539 bool result;
29540 PyObject * obj0 = 0 ;
29541 PyObject * obj1 = 0 ;
29542 PyObject * obj2 = 0 ;
29543 char *kwnames[] = {
29544 (char *) "self",(char *) "x",(char *) "y", NULL
29545 };
29546
29547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29549 if (SWIG_arg_fail(1)) SWIG_fail;
29550 {
29551 arg2 = (int)(SWIG_As_int(obj1));
29552 if (SWIG_arg_fail(2)) SWIG_fail;
29553 }
29554 {
29555 arg3 = (int)(SWIG_As_int(obj2));
29556 if (SWIG_arg_fail(3)) SWIG_fail;
29557 }
29558 {
29559 PyThreadState* __tstate = wxPyBeginAllowThreads();
29560 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29561
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 {
29566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29567 }
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj;
29576 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29577 int arg2 ;
29578 int arg3 ;
29579 wxDragResult arg4 ;
29580 wxDragResult result;
29581 PyObject * obj0 = 0 ;
29582 PyObject * obj1 = 0 ;
29583 PyObject * obj2 = 0 ;
29584 PyObject * obj3 = 0 ;
29585 char *kwnames[] = {
29586 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29587 };
29588
29589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29591 if (SWIG_arg_fail(1)) SWIG_fail;
29592 {
29593 arg2 = (int)(SWIG_As_int(obj1));
29594 if (SWIG_arg_fail(2)) SWIG_fail;
29595 }
29596 {
29597 arg3 = (int)(SWIG_As_int(obj2));
29598 if (SWIG_arg_fail(3)) SWIG_fail;
29599 }
29600 {
29601 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29602 if (SWIG_arg_fail(4)) SWIG_fail;
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29607
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 resultobj = SWIG_From_int((result));
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29619 PyObject *obj;
29620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29621 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29622 Py_INCREF(obj);
29623 return Py_BuildValue((char *)"");
29624 }
29625 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29626 PyObject *resultobj;
29627 wxClipboard *result;
29628 char *kwnames[] = {
29629 NULL
29630 };
29631
29632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29633 {
29634 PyThreadState* __tstate = wxPyBeginAllowThreads();
29635 result = (wxClipboard *)new wxClipboard();
29636
29637 wxPyEndAllowThreads(__tstate);
29638 if (PyErr_Occurred()) SWIG_fail;
29639 }
29640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29648 PyObject *resultobj;
29649 wxClipboard *arg1 = (wxClipboard *) 0 ;
29650 PyObject * obj0 = 0 ;
29651 char *kwnames[] = {
29652 (char *) "self", NULL
29653 };
29654
29655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29657 if (SWIG_arg_fail(1)) SWIG_fail;
29658 {
29659 PyThreadState* __tstate = wxPyBeginAllowThreads();
29660 delete arg1;
29661
29662 wxPyEndAllowThreads(__tstate);
29663 if (PyErr_Occurred()) SWIG_fail;
29664 }
29665 Py_INCREF(Py_None); resultobj = Py_None;
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj;
29674 wxClipboard *arg1 = (wxClipboard *) 0 ;
29675 bool result;
29676 PyObject * obj0 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(1)) SWIG_fail;
29684 {
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (bool)(arg1)->Open();
29687
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 {
29692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29693 }
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29701 PyObject *resultobj;
29702 wxClipboard *arg1 = (wxClipboard *) 0 ;
29703 PyObject * obj0 = 0 ;
29704 char *kwnames[] = {
29705 (char *) "self", NULL
29706 };
29707
29708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29710 if (SWIG_arg_fail(1)) SWIG_fail;
29711 {
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 (arg1)->Close();
29714
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 Py_INCREF(Py_None); resultobj = Py_None;
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj;
29727 wxClipboard *arg1 = (wxClipboard *) 0 ;
29728 bool result;
29729 PyObject * obj0 = 0 ;
29730 char *kwnames[] = {
29731 (char *) "self", NULL
29732 };
29733
29734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29736 if (SWIG_arg_fail(1)) SWIG_fail;
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29740
29741 wxPyEndAllowThreads(__tstate);
29742 if (PyErr_Occurred()) SWIG_fail;
29743 }
29744 {
29745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29746 }
29747 return resultobj;
29748 fail:
29749 return NULL;
29750 }
29751
29752
29753 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29754 PyObject *resultobj;
29755 wxClipboard *arg1 = (wxClipboard *) 0 ;
29756 wxDataObject *arg2 = (wxDataObject *) 0 ;
29757 bool result;
29758 PyObject * obj0 = 0 ;
29759 PyObject * obj1 = 0 ;
29760 char *kwnames[] = {
29761 (char *) "self",(char *) "data", NULL
29762 };
29763
29764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29766 if (SWIG_arg_fail(1)) SWIG_fail;
29767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29768 if (SWIG_arg_fail(2)) SWIG_fail;
29769 {
29770 PyThreadState* __tstate = wxPyBeginAllowThreads();
29771 result = (bool)(arg1)->AddData(arg2);
29772
29773 wxPyEndAllowThreads(__tstate);
29774 if (PyErr_Occurred()) SWIG_fail;
29775 }
29776 {
29777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29778 }
29779 return resultobj;
29780 fail:
29781 return NULL;
29782 }
29783
29784
29785 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29786 PyObject *resultobj;
29787 wxClipboard *arg1 = (wxClipboard *) 0 ;
29788 wxDataObject *arg2 = (wxDataObject *) 0 ;
29789 bool result;
29790 PyObject * obj0 = 0 ;
29791 PyObject * obj1 = 0 ;
29792 char *kwnames[] = {
29793 (char *) "self",(char *) "data", NULL
29794 };
29795
29796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29798 if (SWIG_arg_fail(1)) SWIG_fail;
29799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29800 if (SWIG_arg_fail(2)) SWIG_fail;
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = (bool)(arg1)->SetData(arg2);
29804
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 {
29809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29810 }
29811 return resultobj;
29812 fail:
29813 return NULL;
29814 }
29815
29816
29817 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29818 PyObject *resultobj;
29819 wxClipboard *arg1 = (wxClipboard *) 0 ;
29820 wxDataFormat *arg2 = 0 ;
29821 bool result;
29822 PyObject * obj0 = 0 ;
29823 PyObject * obj1 = 0 ;
29824 char *kwnames[] = {
29825 (char *) "self",(char *) "format", NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29830 if (SWIG_arg_fail(1)) SWIG_fail;
29831 {
29832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29833 if (SWIG_arg_fail(2)) SWIG_fail;
29834 if (arg2 == NULL) {
29835 SWIG_null_ref("wxDataFormat");
29836 }
29837 if (SWIG_arg_fail(2)) SWIG_fail;
29838 }
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29842
29843 wxPyEndAllowThreads(__tstate);
29844 if (PyErr_Occurred()) SWIG_fail;
29845 }
29846 {
29847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj;
29857 wxClipboard *arg1 = (wxClipboard *) 0 ;
29858 wxDataObject *arg2 = 0 ;
29859 bool result;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 char *kwnames[] = {
29863 (char *) "self",(char *) "data", NULL
29864 };
29865
29866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29868 if (SWIG_arg_fail(1)) SWIG_fail;
29869 {
29870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29871 if (SWIG_arg_fail(2)) SWIG_fail;
29872 if (arg2 == NULL) {
29873 SWIG_null_ref("wxDataObject");
29874 }
29875 if (SWIG_arg_fail(2)) SWIG_fail;
29876 }
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 result = (bool)(arg1)->GetData(*arg2);
29880
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 {
29885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29886 }
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj;
29895 wxClipboard *arg1 = (wxClipboard *) 0 ;
29896 PyObject * obj0 = 0 ;
29897 char *kwnames[] = {
29898 (char *) "self", NULL
29899 };
29900
29901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29903 if (SWIG_arg_fail(1)) SWIG_fail;
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 (arg1)->Clear();
29907
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 Py_INCREF(Py_None); resultobj = Py_None;
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj;
29920 wxClipboard *arg1 = (wxClipboard *) 0 ;
29921 bool result;
29922 PyObject * obj0 = 0 ;
29923 char *kwnames[] = {
29924 (char *) "self", NULL
29925 };
29926
29927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29929 if (SWIG_arg_fail(1)) SWIG_fail;
29930 {
29931 PyThreadState* __tstate = wxPyBeginAllowThreads();
29932 result = (bool)(arg1)->Flush();
29933
29934 wxPyEndAllowThreads(__tstate);
29935 if (PyErr_Occurred()) SWIG_fail;
29936 }
29937 {
29938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29939 }
29940 return resultobj;
29941 fail:
29942 return NULL;
29943 }
29944
29945
29946 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29947 PyObject *resultobj;
29948 wxClipboard *arg1 = (wxClipboard *) 0 ;
29949 bool arg2 = (bool) true ;
29950 PyObject * obj0 = 0 ;
29951 PyObject * obj1 = 0 ;
29952 char *kwnames[] = {
29953 (char *) "self",(char *) "primary", NULL
29954 };
29955
29956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29958 if (SWIG_arg_fail(1)) SWIG_fail;
29959 if (obj1) {
29960 {
29961 arg2 = (bool)(SWIG_As_bool(obj1));
29962 if (SWIG_arg_fail(2)) SWIG_fail;
29963 }
29964 }
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 (arg1)->UsePrimarySelection(arg2);
29968
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 Py_INCREF(Py_None); resultobj = Py_None;
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29980 PyObject *resultobj;
29981 wxClipboard *result;
29982 char *kwnames[] = {
29983 NULL
29984 };
29985
29986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 result = (wxClipboard *)wxClipboard::Get();
29990
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30002 PyObject *obj;
30003 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30004 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30005 Py_INCREF(obj);
30006 return Py_BuildValue((char *)"");
30007 }
30008 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30009 PyObject *resultobj;
30010 wxClipboard *arg1 = (wxClipboard *) NULL ;
30011 wxClipboardLocker *result;
30012 PyObject * obj0 = 0 ;
30013 char *kwnames[] = {
30014 (char *) "clipboard", NULL
30015 };
30016
30017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30018 if (obj0) {
30019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30020 if (SWIG_arg_fail(1)) SWIG_fail;
30021 }
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30025
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30037 PyObject *resultobj;
30038 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30039 PyObject * obj0 = 0 ;
30040 char *kwnames[] = {
30041 (char *) "self", NULL
30042 };
30043
30044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30046 if (SWIG_arg_fail(1)) SWIG_fail;
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 delete arg1;
30050
30051 wxPyEndAllowThreads(__tstate);
30052 if (PyErr_Occurred()) SWIG_fail;
30053 }
30054 Py_INCREF(Py_None); resultobj = Py_None;
30055 return resultobj;
30056 fail:
30057 return NULL;
30058 }
30059
30060
30061 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30062 PyObject *resultobj;
30063 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30064 bool result;
30065 PyObject * obj0 = 0 ;
30066 char *kwnames[] = {
30067 (char *) "self", NULL
30068 };
30069
30070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30072 if (SWIG_arg_fail(1)) SWIG_fail;
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (bool)wxClipboardLocker___nonzero__(arg1);
30076
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 {
30081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30082 }
30083 return resultobj;
30084 fail:
30085 return NULL;
30086 }
30087
30088
30089 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30090 PyObject *obj;
30091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30092 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30093 Py_INCREF(obj);
30094 return Py_BuildValue((char *)"");
30095 }
30096 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30097 PyObject *resultobj;
30098 int arg1 = (int) 0 ;
30099 int arg2 = (int) 0 ;
30100 int arg3 = (int) 0 ;
30101 int arg4 = (int) 0 ;
30102 wxVideoMode *result;
30103 PyObject * obj0 = 0 ;
30104 PyObject * obj1 = 0 ;
30105 PyObject * obj2 = 0 ;
30106 PyObject * obj3 = 0 ;
30107 char *kwnames[] = {
30108 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30109 };
30110
30111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30112 if (obj0) {
30113 {
30114 arg1 = (int)(SWIG_As_int(obj0));
30115 if (SWIG_arg_fail(1)) SWIG_fail;
30116 }
30117 }
30118 if (obj1) {
30119 {
30120 arg2 = (int)(SWIG_As_int(obj1));
30121 if (SWIG_arg_fail(2)) SWIG_fail;
30122 }
30123 }
30124 if (obj2) {
30125 {
30126 arg3 = (int)(SWIG_As_int(obj2));
30127 if (SWIG_arg_fail(3)) SWIG_fail;
30128 }
30129 }
30130 if (obj3) {
30131 {
30132 arg4 = (int)(SWIG_As_int(obj3));
30133 if (SWIG_arg_fail(4)) SWIG_fail;
30134 }
30135 }
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30139
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj;
30152 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30153 PyObject * obj0 = 0 ;
30154 char *kwnames[] = {
30155 (char *) "self", NULL
30156 };
30157
30158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30160 if (SWIG_arg_fail(1)) SWIG_fail;
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 delete arg1;
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj;
30177 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30178 wxVideoMode *arg2 = 0 ;
30179 bool result;
30180 PyObject * obj0 = 0 ;
30181 PyObject * obj1 = 0 ;
30182 char *kwnames[] = {
30183 (char *) "self",(char *) "other", NULL
30184 };
30185
30186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(1)) SWIG_fail;
30189 {
30190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30191 if (SWIG_arg_fail(2)) SWIG_fail;
30192 if (arg2 == NULL) {
30193 SWIG_null_ref("wxVideoMode");
30194 }
30195 if (SWIG_arg_fail(2)) SWIG_fail;
30196 }
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30200
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 {
30205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30206 }
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30214 PyObject *resultobj;
30215 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30216 int result;
30217 PyObject * obj0 = 0 ;
30218 char *kwnames[] = {
30219 (char *) "self", NULL
30220 };
30221
30222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30224 if (SWIG_arg_fail(1)) SWIG_fail;
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30228
30229 wxPyEndAllowThreads(__tstate);
30230 if (PyErr_Occurred()) SWIG_fail;
30231 }
30232 {
30233 resultobj = SWIG_From_int((int)(result));
30234 }
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj;
30243 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30244 int result;
30245 PyObject * obj0 = 0 ;
30246 char *kwnames[] = {
30247 (char *) "self", NULL
30248 };
30249
30250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30252 if (SWIG_arg_fail(1)) SWIG_fail;
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30256
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 {
30261 resultobj = SWIG_From_int((int)(result));
30262 }
30263 return resultobj;
30264 fail:
30265 return NULL;
30266 }
30267
30268
30269 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30270 PyObject *resultobj;
30271 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30272 int result;
30273 PyObject * obj0 = 0 ;
30274 char *kwnames[] = {
30275 (char *) "self", NULL
30276 };
30277
30278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30280 if (SWIG_arg_fail(1)) SWIG_fail;
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30284
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 {
30289 resultobj = SWIG_From_int((int)(result));
30290 }
30291 return resultobj;
30292 fail:
30293 return NULL;
30294 }
30295
30296
30297 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30298 PyObject *resultobj;
30299 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30300 bool result;
30301 PyObject * obj0 = 0 ;
30302 char *kwnames[] = {
30303 (char *) "self", NULL
30304 };
30305
30306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30308 if (SWIG_arg_fail(1)) SWIG_fail;
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30312
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 {
30317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30318 }
30319 return resultobj;
30320 fail:
30321 return NULL;
30322 }
30323
30324
30325 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30326 PyObject *resultobj;
30327 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30328 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30329 bool result;
30330 PyObject * obj0 = 0 ;
30331 PyObject * obj1 = 0 ;
30332 char *kwnames[] = {
30333 (char *) "self",(char *) "other", NULL
30334 };
30335
30336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30338 if (SWIG_arg_fail(1)) SWIG_fail;
30339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30340 if (SWIG_arg_fail(2)) SWIG_fail;
30341 {
30342 PyThreadState* __tstate = wxPyBeginAllowThreads();
30343 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30344
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 {
30349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30350 }
30351 return resultobj;
30352 fail:
30353 return NULL;
30354 }
30355
30356
30357 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30358 PyObject *resultobj;
30359 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30360 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30361 bool result;
30362 PyObject * obj0 = 0 ;
30363 PyObject * obj1 = 0 ;
30364 char *kwnames[] = {
30365 (char *) "self",(char *) "other", NULL
30366 };
30367
30368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30370 if (SWIG_arg_fail(1)) SWIG_fail;
30371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30372 if (SWIG_arg_fail(2)) SWIG_fail;
30373 {
30374 PyThreadState* __tstate = wxPyBeginAllowThreads();
30375 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30376
30377 wxPyEndAllowThreads(__tstate);
30378 if (PyErr_Occurred()) SWIG_fail;
30379 }
30380 {
30381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30382 }
30383 return resultobj;
30384 fail:
30385 return NULL;
30386 }
30387
30388
30389 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30390 PyObject *resultobj;
30391 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30392 int arg2 ;
30393 PyObject * obj0 = 0 ;
30394 PyObject * obj1 = 0 ;
30395 char *kwnames[] = {
30396 (char *) "self",(char *) "w", NULL
30397 };
30398
30399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30401 if (SWIG_arg_fail(1)) SWIG_fail;
30402 {
30403 arg2 = (int)(SWIG_As_int(obj1));
30404 if (SWIG_arg_fail(2)) SWIG_fail;
30405 }
30406 if (arg1) (arg1)->w = arg2;
30407
30408 Py_INCREF(Py_None); resultobj = Py_None;
30409 return resultobj;
30410 fail:
30411 return NULL;
30412 }
30413
30414
30415 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30416 PyObject *resultobj;
30417 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30418 int result;
30419 PyObject * obj0 = 0 ;
30420 char *kwnames[] = {
30421 (char *) "self", NULL
30422 };
30423
30424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30426 if (SWIG_arg_fail(1)) SWIG_fail;
30427 result = (int) ((arg1)->w);
30428
30429 {
30430 resultobj = SWIG_From_int((int)(result));
30431 }
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30439 PyObject *resultobj;
30440 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30441 int arg2 ;
30442 PyObject * obj0 = 0 ;
30443 PyObject * obj1 = 0 ;
30444 char *kwnames[] = {
30445 (char *) "self",(char *) "h", NULL
30446 };
30447
30448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30450 if (SWIG_arg_fail(1)) SWIG_fail;
30451 {
30452 arg2 = (int)(SWIG_As_int(obj1));
30453 if (SWIG_arg_fail(2)) SWIG_fail;
30454 }
30455 if (arg1) (arg1)->h = arg2;
30456
30457 Py_INCREF(Py_None); resultobj = Py_None;
30458 return resultobj;
30459 fail:
30460 return NULL;
30461 }
30462
30463
30464 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30465 PyObject *resultobj;
30466 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30467 int result;
30468 PyObject * obj0 = 0 ;
30469 char *kwnames[] = {
30470 (char *) "self", NULL
30471 };
30472
30473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30475 if (SWIG_arg_fail(1)) SWIG_fail;
30476 result = (int) ((arg1)->h);
30477
30478 {
30479 resultobj = SWIG_From_int((int)(result));
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj;
30489 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30490 int arg2 ;
30491 PyObject * obj0 = 0 ;
30492 PyObject * obj1 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self",(char *) "bpp", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 arg2 = (int)(SWIG_As_int(obj1));
30502 if (SWIG_arg_fail(2)) SWIG_fail;
30503 }
30504 if (arg1) (arg1)->bpp = arg2;
30505
30506 Py_INCREF(Py_None); resultobj = Py_None;
30507 return resultobj;
30508 fail:
30509 return NULL;
30510 }
30511
30512
30513 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30514 PyObject *resultobj;
30515 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30516 int result;
30517 PyObject * obj0 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 result = (int) ((arg1)->bpp);
30526
30527 {
30528 resultobj = SWIG_From_int((int)(result));
30529 }
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj;
30538 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30539 int arg2 ;
30540 PyObject * obj0 = 0 ;
30541 PyObject * obj1 = 0 ;
30542 char *kwnames[] = {
30543 (char *) "self",(char *) "refresh", NULL
30544 };
30545
30546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30548 if (SWIG_arg_fail(1)) SWIG_fail;
30549 {
30550 arg2 = (int)(SWIG_As_int(obj1));
30551 if (SWIG_arg_fail(2)) SWIG_fail;
30552 }
30553 if (arg1) (arg1)->refresh = arg2;
30554
30555 Py_INCREF(Py_None); resultobj = Py_None;
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj;
30564 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30565 int result;
30566 PyObject * obj0 = 0 ;
30567 char *kwnames[] = {
30568 (char *) "self", NULL
30569 };
30570
30571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30573 if (SWIG_arg_fail(1)) SWIG_fail;
30574 result = (int) ((arg1)->refresh);
30575
30576 {
30577 resultobj = SWIG_From_int((int)(result));
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30586 PyObject *obj;
30587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30588 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30589 Py_INCREF(obj);
30590 return Py_BuildValue((char *)"");
30591 }
30592 static int _wrap_DefaultVideoMode_set(PyObject *) {
30593 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30594 return 1;
30595 }
30596
30597
30598 static PyObject *_wrap_DefaultVideoMode_get(void) {
30599 PyObject *pyobj;
30600
30601 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30602 return pyobj;
30603 }
30604
30605
30606 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj;
30608 size_t arg1 = (size_t) 0 ;
30609 wxDisplay *result;
30610 PyObject * obj0 = 0 ;
30611 char *kwnames[] = {
30612 (char *) "index", NULL
30613 };
30614
30615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30616 if (obj0) {
30617 {
30618 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30619 if (SWIG_arg_fail(1)) SWIG_fail;
30620 }
30621 }
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (wxDisplay *)new wxDisplay(arg1);
30625
30626 wxPyEndAllowThreads(__tstate);
30627 if (PyErr_Occurred()) SWIG_fail;
30628 }
30629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30630 return resultobj;
30631 fail:
30632 return NULL;
30633 }
30634
30635
30636 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30637 PyObject *resultobj;
30638 wxDisplay *arg1 = (wxDisplay *) 0 ;
30639 PyObject * obj0 = 0 ;
30640 char *kwnames[] = {
30641 (char *) "self", NULL
30642 };
30643
30644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30646 if (SWIG_arg_fail(1)) SWIG_fail;
30647 {
30648 PyThreadState* __tstate = wxPyBeginAllowThreads();
30649 delete arg1;
30650
30651 wxPyEndAllowThreads(__tstate);
30652 if (PyErr_Occurred()) SWIG_fail;
30653 }
30654 Py_INCREF(Py_None); resultobj = Py_None;
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30662 PyObject *resultobj;
30663 size_t result;
30664 char *kwnames[] = {
30665 NULL
30666 };
30667
30668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30669 {
30670 PyThreadState* __tstate = wxPyBeginAllowThreads();
30671 result = (size_t)wxDisplay::GetCount();
30672
30673 wxPyEndAllowThreads(__tstate);
30674 if (PyErr_Occurred()) SWIG_fail;
30675 }
30676 {
30677 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30678 }
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj;
30687 wxPoint *arg1 = 0 ;
30688 int result;
30689 wxPoint temp1 ;
30690 PyObject * obj0 = 0 ;
30691 char *kwnames[] = {
30692 (char *) "pt", NULL
30693 };
30694
30695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30696 {
30697 arg1 = &temp1;
30698 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30699 }
30700 {
30701 PyThreadState* __tstate = wxPyBeginAllowThreads();
30702 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30703
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 {
30708 resultobj = SWIG_From_int((int)(result));
30709 }
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 int result;
30720 PyObject * obj0 = 0 ;
30721 char *kwnames[] = {
30722 (char *) "window", NULL
30723 };
30724
30725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30727 if (SWIG_arg_fail(1)) SWIG_fail;
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 result = (int)wxDisplay::GetFromWindow(arg1);
30731
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 {
30736 resultobj = SWIG_From_int((int)(result));
30737 }
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30745 PyObject *resultobj;
30746 wxDisplay *arg1 = (wxDisplay *) 0 ;
30747 bool result;
30748 PyObject * obj0 = 0 ;
30749 char *kwnames[] = {
30750 (char *) "self", NULL
30751 };
30752
30753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30755 if (SWIG_arg_fail(1)) SWIG_fail;
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 result = (bool)((wxDisplay const *)arg1)->IsOk();
30759
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 {
30764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30765 }
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30773 PyObject *resultobj;
30774 wxDisplay *arg1 = (wxDisplay *) 0 ;
30775 wxRect result;
30776 PyObject * obj0 = 0 ;
30777 char *kwnames[] = {
30778 (char *) "self", NULL
30779 };
30780
30781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30783 if (SWIG_arg_fail(1)) SWIG_fail;
30784 {
30785 PyThreadState* __tstate = wxPyBeginAllowThreads();
30786 result = ((wxDisplay const *)arg1)->GetGeometry();
30787
30788 wxPyEndAllowThreads(__tstate);
30789 if (PyErr_Occurred()) SWIG_fail;
30790 }
30791 {
30792 wxRect * resultptr;
30793 resultptr = new wxRect((wxRect &)(result));
30794 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30795 }
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj;
30804 wxDisplay *arg1 = (wxDisplay *) 0 ;
30805 wxString result;
30806 PyObject * obj0 = 0 ;
30807 char *kwnames[] = {
30808 (char *) "self", NULL
30809 };
30810
30811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30813 if (SWIG_arg_fail(1)) SWIG_fail;
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = ((wxDisplay const *)arg1)->GetName();
30817
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 {
30822 #if wxUSE_UNICODE
30823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30824 #else
30825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30826 #endif
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30835 PyObject *resultobj;
30836 wxDisplay *arg1 = (wxDisplay *) 0 ;
30837 bool result;
30838 PyObject * obj0 = 0 ;
30839 char *kwnames[] = {
30840 (char *) "self", NULL
30841 };
30842
30843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30845 if (SWIG_arg_fail(1)) SWIG_fail;
30846 {
30847 PyThreadState* __tstate = wxPyBeginAllowThreads();
30848 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30849
30850 wxPyEndAllowThreads(__tstate);
30851 if (PyErr_Occurred()) SWIG_fail;
30852 }
30853 {
30854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30855 }
30856 return resultobj;
30857 fail:
30858 return NULL;
30859 }
30860
30861
30862 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30863 PyObject *resultobj;
30864 wxDisplay *arg1 = (wxDisplay *) 0 ;
30865 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30866 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30867 PyObject *result;
30868 PyObject * obj0 = 0 ;
30869 PyObject * obj1 = 0 ;
30870 char *kwnames[] = {
30871 (char *) "self",(char *) "mode", NULL
30872 };
30873
30874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30876 if (SWIG_arg_fail(1)) SWIG_fail;
30877 if (obj1) {
30878 {
30879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30880 if (SWIG_arg_fail(2)) SWIG_fail;
30881 if (arg2 == NULL) {
30882 SWIG_null_ref("wxVideoMode");
30883 }
30884 if (SWIG_arg_fail(2)) SWIG_fail;
30885 }
30886 }
30887 {
30888 PyThreadState* __tstate = wxPyBeginAllowThreads();
30889 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30890
30891 wxPyEndAllowThreads(__tstate);
30892 if (PyErr_Occurred()) SWIG_fail;
30893 }
30894 resultobj = result;
30895 return resultobj;
30896 fail:
30897 return NULL;
30898 }
30899
30900
30901 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30902 PyObject *resultobj;
30903 wxDisplay *arg1 = (wxDisplay *) 0 ;
30904 wxVideoMode result;
30905 PyObject * obj0 = 0 ;
30906 char *kwnames[] = {
30907 (char *) "self", NULL
30908 };
30909
30910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30912 if (SWIG_arg_fail(1)) SWIG_fail;
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30916
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 {
30921 wxVideoMode * resultptr;
30922 resultptr = new wxVideoMode((wxVideoMode &)(result));
30923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30924 }
30925 return resultobj;
30926 fail:
30927 return NULL;
30928 }
30929
30930
30931 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30932 PyObject *resultobj;
30933 wxDisplay *arg1 = (wxDisplay *) 0 ;
30934 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30935 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30936 bool result;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char *kwnames[] = {
30940 (char *) "self",(char *) "mode", NULL
30941 };
30942
30943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30945 if (SWIG_arg_fail(1)) SWIG_fail;
30946 if (obj1) {
30947 {
30948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30949 if (SWIG_arg_fail(2)) SWIG_fail;
30950 if (arg2 == NULL) {
30951 SWIG_null_ref("wxVideoMode");
30952 }
30953 if (SWIG_arg_fail(2)) SWIG_fail;
30954 }
30955 }
30956 {
30957 PyThreadState* __tstate = wxPyBeginAllowThreads();
30958 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30959
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 {
30964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30965 }
30966 return resultobj;
30967 fail:
30968 return NULL;
30969 }
30970
30971
30972 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30973 PyObject *resultobj;
30974 wxDisplay *arg1 = (wxDisplay *) 0 ;
30975 PyObject * obj0 = 0 ;
30976 char *kwnames[] = {
30977 (char *) "self", NULL
30978 };
30979
30980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30982 if (SWIG_arg_fail(1)) SWIG_fail;
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 (arg1)->ResetMode();
30986
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 Py_INCREF(Py_None); resultobj = Py_None;
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30998 PyObject *obj;
30999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31000 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31001 Py_INCREF(obj);
31002 return Py_BuildValue((char *)"");
31003 }
31004 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31005 PyObject *resultobj;
31006 wxStandardPaths *result;
31007 char *kwnames[] = {
31008 NULL
31009 };
31010
31011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = (wxStandardPaths *)StandardPaths_Get();
31015
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj;
31028 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31029 wxString result;
31030 PyObject * obj0 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(1)) SWIG_fail;
31038 {
31039 PyThreadState* __tstate = wxPyBeginAllowThreads();
31040 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31041
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 {
31046 #if wxUSE_UNICODE
31047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31048 #else
31049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31050 #endif
31051 }
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj;
31060 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31061 wxString result;
31062 PyObject * obj0 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(1)) SWIG_fail;
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31073
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 {
31078 #if wxUSE_UNICODE
31079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31080 #else
31081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31082 #endif
31083 }
31084 return resultobj;
31085 fail:
31086 return NULL;
31087 }
31088
31089
31090 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31091 PyObject *resultobj;
31092 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31093 wxString result;
31094 PyObject * obj0 = 0 ;
31095 char *kwnames[] = {
31096 (char *) "self", NULL
31097 };
31098
31099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31101 if (SWIG_arg_fail(1)) SWIG_fail;
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31105
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 {
31110 #if wxUSE_UNICODE
31111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31112 #else
31113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31114 #endif
31115 }
31116 return resultobj;
31117 fail:
31118 return NULL;
31119 }
31120
31121
31122 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31123 PyObject *resultobj;
31124 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31125 wxString result;
31126 PyObject * obj0 = 0 ;
31127 char *kwnames[] = {
31128 (char *) "self", NULL
31129 };
31130
31131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31133 if (SWIG_arg_fail(1)) SWIG_fail;
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31137
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 {
31142 #if wxUSE_UNICODE
31143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31144 #else
31145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31146 #endif
31147 }
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj;
31156 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31157 wxString result;
31158 PyObject * obj0 = 0 ;
31159 char *kwnames[] = {
31160 (char *) "self", NULL
31161 };
31162
31163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31165 if (SWIG_arg_fail(1)) SWIG_fail;
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31169
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 {
31174 #if wxUSE_UNICODE
31175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31176 #else
31177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31178 #endif
31179 }
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31187 PyObject *resultobj;
31188 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31189 wxString result;
31190 PyObject * obj0 = 0 ;
31191 char *kwnames[] = {
31192 (char *) "self", NULL
31193 };
31194
31195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31197 if (SWIG_arg_fail(1)) SWIG_fail;
31198 {
31199 PyThreadState* __tstate = wxPyBeginAllowThreads();
31200 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31201
31202 wxPyEndAllowThreads(__tstate);
31203 if (PyErr_Occurred()) SWIG_fail;
31204 }
31205 {
31206 #if wxUSE_UNICODE
31207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31208 #else
31209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31210 #endif
31211 }
31212 return resultobj;
31213 fail:
31214 return NULL;
31215 }
31216
31217
31218 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31219 PyObject *resultobj;
31220 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31221 wxString result;
31222 PyObject * obj0 = 0 ;
31223 char *kwnames[] = {
31224 (char *) "self", NULL
31225 };
31226
31227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31229 if (SWIG_arg_fail(1)) SWIG_fail;
31230 {
31231 PyThreadState* __tstate = wxPyBeginAllowThreads();
31232 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31233
31234 wxPyEndAllowThreads(__tstate);
31235 if (PyErr_Occurred()) SWIG_fail;
31236 }
31237 {
31238 #if wxUSE_UNICODE
31239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31240 #else
31241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31242 #endif
31243 }
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31253 wxString *arg2 = 0 ;
31254 bool temp2 = false ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31257 char *kwnames[] = {
31258 (char *) "self",(char *) "prefix", NULL
31259 };
31260
31261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31263 if (SWIG_arg_fail(1)) SWIG_fail;
31264 {
31265 arg2 = wxString_in_helper(obj1);
31266 if (arg2 == NULL) SWIG_fail;
31267 temp2 = true;
31268 }
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31272
31273 wxPyEndAllowThreads(__tstate);
31274 if (PyErr_Occurred()) SWIG_fail;
31275 }
31276 Py_INCREF(Py_None); resultobj = Py_None;
31277 {
31278 if (temp2)
31279 delete arg2;
31280 }
31281 return resultobj;
31282 fail:
31283 {
31284 if (temp2)
31285 delete arg2;
31286 }
31287 return NULL;
31288 }
31289
31290
31291 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31292 PyObject *resultobj;
31293 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31294 wxString result;
31295 PyObject * obj0 = 0 ;
31296 char *kwnames[] = {
31297 (char *) "self", NULL
31298 };
31299
31300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31302 if (SWIG_arg_fail(1)) SWIG_fail;
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 result = wxStandardPaths_GetInstallPrefix(arg1);
31306
31307 wxPyEndAllowThreads(__tstate);
31308 if (PyErr_Occurred()) SWIG_fail;
31309 }
31310 {
31311 #if wxUSE_UNICODE
31312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31313 #else
31314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31315 #endif
31316 }
31317 return resultobj;
31318 fail:
31319 return NULL;
31320 }
31321
31322
31323 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31324 PyObject *obj;
31325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31326 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31327 Py_INCREF(obj);
31328 return Py_BuildValue((char *)"");
31329 }
31330 static PyMethodDef SwigMethods[] = {
31331 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31338 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31345 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31409 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31417 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31435 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31438 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31441 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31444 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31450 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31464 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31470 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31476 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31479 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31493 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31496 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31497 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31500 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31527 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31529 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31531 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31533 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31540 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31546 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31560 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31564 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31567 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31584 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31592 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31639 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31657 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31667 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31683 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31699 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31713 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31722 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31765 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31768 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31771 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31775 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31868 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31869 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31870 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31871 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31888 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31933 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31967 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31975 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31976 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31981 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31990 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31997 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32000 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32003 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32008 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32011 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32015 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32018 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32022 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32023 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32027 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32031 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32035 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32045 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32056 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32064 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32072 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32086 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32090 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32108 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32122 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32133 { NULL, NULL, 0, NULL }
32134 };
32135
32136
32137 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32138
32139 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32140 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32141 }
32142 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32143 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32144 }
32145 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32146 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32147 }
32148 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32149 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32150 }
32151 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32152 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32153 }
32154 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32155 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32156 }
32157 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32158 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32159 }
32160 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32161 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32162 }
32163 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32164 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32165 }
32166 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32167 return (void *)((wxEvent *) ((wxPyEvent *) x));
32168 }
32169 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32170 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32171 }
32172 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32173 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32174 }
32175 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32176 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32177 }
32178 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32180 }
32181 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32182 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32183 }
32184 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32185 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32186 }
32187 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32188 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32189 }
32190 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32191 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32192 }
32193 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32194 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32195 }
32196 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32197 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32198 }
32199 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32200 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32201 }
32202 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32203 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32204 }
32205 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32206 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32207 }
32208 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32209 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32210 }
32211 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32212 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32213 }
32214 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32215 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32216 }
32217 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32218 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32219 }
32220 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32221 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32222 }
32223 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32224 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32225 }
32226 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32227 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32228 }
32229 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32230 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32231 }
32232 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32233 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32234 }
32235 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32236 return (void *)((wxEvent *) ((wxShowEvent *) x));
32237 }
32238 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32239 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32240 }
32241 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32242 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32243 }
32244 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32245 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32246 }
32247 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32248 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32249 }
32250 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32251 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32252 }
32253 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32254 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32255 }
32256 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32257 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32258 }
32259 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32260 return (void *)((wxConfigBase *) ((wxConfig *) x));
32261 }
32262 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32263 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32264 }
32265 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32266 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32267 }
32268 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32269 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32270 }
32271 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32272 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32273 }
32274 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32275 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32276 }
32277 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32278 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32279 }
32280 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32281 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32282 }
32283 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32284 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32285 }
32286 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32287 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32288 }
32289 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32290 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32291 }
32292 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32293 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32294 }
32295 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32296 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32297 }
32298 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32299 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32300 }
32301 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32302 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32303 }
32304 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32305 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32306 }
32307 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32308 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32309 }
32310 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32311 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32312 }
32313 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32314 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32315 }
32316 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32317 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32318 }
32319 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32320 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32321 }
32322 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32323 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32324 }
32325 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32326 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32327 }
32328 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32329 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32330 }
32331 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32332 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32333 }
32334 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32335 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32336 }
32337 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32338 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32339 }
32340 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32341 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32342 }
32343 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32344 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32345 }
32346 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32347 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32348 }
32349 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32350 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32351 }
32352 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32353 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32354 }
32355 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32356 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32357 }
32358 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32359 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32360 }
32361 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32362 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32363 }
32364 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32365 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32366 }
32367 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32368 return (void *)((wxObject *) ((wxSizerItem *) x));
32369 }
32370 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32371 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32372 }
32373 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32374 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32375 }
32376 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32377 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32378 }
32379 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32380 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32381 }
32382 static void *_p_wxSizerTo_p_wxObject(void *x) {
32383 return (void *)((wxObject *) ((wxSizer *) x));
32384 }
32385 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32386 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32387 }
32388 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32389 return (void *)((wxObject *) ((wxFileHistory *) x));
32390 }
32391 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32392 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32393 }
32394 static void *_p_wxEventTo_p_wxObject(void *x) {
32395 return (void *)((wxObject *) ((wxEvent *) x));
32396 }
32397 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32398 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32399 }
32400 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32401 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32402 }
32403 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32404 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32405 }
32406 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32407 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32408 }
32409 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32410 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32411 }
32412 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32413 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32414 }
32415 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32416 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32417 }
32418 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32419 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32420 }
32421 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32422 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32423 }
32424 static void *_p_wxControlTo_p_wxObject(void *x) {
32425 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32426 }
32427 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32428 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32429 }
32430 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32431 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32432 }
32433 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32434 return (void *)((wxObject *) ((wxFSFile *) x));
32435 }
32436 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32437 return (void *)((wxObject *) ((wxClipboard *) x));
32438 }
32439 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32440 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32441 }
32442 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32443 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32444 }
32445 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32446 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32447 }
32448 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32449 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32450 }
32451 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32452 return (void *)((wxObject *) ((wxToolTip *) x));
32453 }
32454 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32455 return (void *)((wxObject *) ((wxMenuItem *) x));
32456 }
32457 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32459 }
32460 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32461 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32462 }
32463 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32464 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32465 }
32466 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32467 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32468 }
32469 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32470 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32471 }
32472 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32473 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32474 }
32475 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32476 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32477 }
32478 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32479 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32480 }
32481 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32482 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32483 }
32484 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32485 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32486 }
32487 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32488 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32489 }
32490 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32491 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32492 }
32493 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32494 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32495 }
32496 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32497 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32498 }
32499 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32500 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32501 }
32502 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32504 }
32505 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32507 }
32508 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32510 }
32511 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32513 }
32514 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) ((wxImageHandler *) x));
32516 }
32517 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32518 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32519 }
32520 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) ((wxEvtHandler *) x));
32522 }
32523 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32525 }
32526 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32528 }
32529 static void *_p_wxImageTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) ((wxImage *) x));
32531 }
32532 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32534 }
32535 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) ((wxSystemOptions *) x));
32537 }
32538 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32540 }
32541 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32543 }
32544 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32546 }
32547 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32549 }
32550 static void *_p_wxWindowTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32552 }
32553 static void *_p_wxMenuTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32555 }
32556 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32558 }
32559 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32561 }
32562 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) ((wxFileSystem *) x));
32564 }
32565 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32567 }
32568 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32570 }
32571 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32573 }
32574 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32576 }
32577 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32579 }
32580 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32582 }
32583 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) ((wxBusyInfo *) x));
32585 }
32586 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32588 }
32589 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32591 }
32592 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32594 }
32595 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32597 }
32598 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32600 }
32601 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32603 }
32604 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32606 }
32607 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32609 }
32610 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32612 }
32613 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32615 }
32616 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32617 return (void *)((wxLog *) ((wxLogStderr *) x));
32618 }
32619 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32620 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32621 }
32622 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32623 return (void *)((wxLog *) ((wxLogWindow *) x));
32624 }
32625 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32626 return (void *)((wxLog *) ((wxLogChain *) x));
32627 }
32628 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32629 return (void *)((wxLog *) ((wxLogGui *) x));
32630 }
32631 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32632 return (void *)((wxLog *) ((wxPyLog *) x));
32633 }
32634 static void *_p_wxControlTo_p_wxWindow(void *x) {
32635 return (void *)((wxWindow *) ((wxControl *) x));
32636 }
32637 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32638 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32639 }
32640 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32641 return (void *)((wxWindow *) ((wxMenuBar *) x));
32642 }
32643 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32644 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32645 }
32646 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32647 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32648 }
32649 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}};
32650 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}};
32651 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}};
32652 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}};
32653 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}};
32654 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}};
32655 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}};
32656 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}};
32657 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}};
32658 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}};
32659 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}};
32660 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}};
32661 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}};
32662 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}};
32663 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}};
32664 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}};
32665 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}};
32666 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}};
32667 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}};
32668 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}};
32669 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}};
32670 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}};
32671 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}};
32672 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}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 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}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687 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}};
32688 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}};
32689 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}};
32690 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}};
32691 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}};
32692 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}};
32693 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}};
32694 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}};
32695 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}};
32696 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}};
32697 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}};
32698 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}};
32699 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}};
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746
32747 static swig_type_info *swig_types_initial[] = {
32748 _swigt__p_wxLogChain,
32749 _swigt__p_wxMutexGuiLocker,
32750 _swigt__p_wxMetafile,
32751 _swigt__p_wxFileHistory,
32752 _swigt__p_wxLog,
32753 _swigt__p_wxMenu,
32754 _swigt__p_wxEvent,
32755 _swigt__p_wxDateTime__TimeZone,
32756 _swigt__p_wxConfigBase,
32757 _swigt__p_wxDisplay,
32758 _swigt__p_wxFileType,
32759 _swigt__p_wxLogGui,
32760 _swigt__p_wxFont,
32761 _swigt__p_wxDataFormat,
32762 _swigt__p_wxTimerEvent,
32763 _swigt__p_wxCaret,
32764 _swigt__ptrdiff_t,
32765 _swigt__std__ptrdiff_t,
32766 _swigt__p_int,
32767 _swigt__p_wxSize,
32768 _swigt__p_wxClipboard,
32769 _swigt__p_wxStopWatch,
32770 _swigt__p_wxDC,
32771 _swigt__p_wxClipboardLocker,
32772 _swigt__p_wxIcon,
32773 _swigt__p_wxLogStderr,
32774 _swigt__p_wxLogTextCtrl,
32775 _swigt__p_wxTextCtrl,
32776 _swigt__p_wxBusyCursor,
32777 _swigt__p_wxBitmapDataObject,
32778 _swigt__p_wxTextDataObject,
32779 _swigt__p_wxDataObject,
32780 _swigt__p_wxPyTextDataObject,
32781 _swigt__p_wxPyBitmapDataObject,
32782 _swigt__p_wxFileDataObject,
32783 _swigt__p_wxCustomDataObject,
32784 _swigt__p_wxURLDataObject,
32785 _swigt__p_wxMetafileDataObject,
32786 _swigt__p_wxSound,
32787 _swigt__p_wxTimerRunner,
32788 _swigt__p_wxLogWindow,
32789 _swigt__p_wxTimeSpan,
32790 _swigt__p_wxArrayString,
32791 _swigt__p_wxWindowDisabler,
32792 _swigt__p_form_ops_t,
32793 _swigt__p_wxToolTip,
32794 _swigt__p_wxDataObjectComposite,
32795 _swigt__p_wxSystemSettings,
32796 _swigt__p_wxFileConfig,
32797 _swigt__p_wxVideoMode,
32798 _swigt__p_wxDataObjectSimple,
32799 _swigt__p_wxPyDataObjectSimple,
32800 _swigt__p_wxDuplexMode,
32801 _swigt__p_wxEvtHandler,
32802 _swigt__p_wxRect,
32803 _swigt__p_char,
32804 _swigt__p_wxSingleInstanceChecker,
32805 _swigt__p_wxStandardPaths,
32806 _swigt__p_wxFileTypeInfo,
32807 _swigt__p_wxFrame,
32808 _swigt__p_wxTimer,
32809 _swigt__p_wxPaperSize,
32810 _swigt__p_wxMimeTypesManager,
32811 _swigt__p_wxPyArtProvider,
32812 _swigt__p_wxPyTipProvider,
32813 _swigt__p_wxTipProvider,
32814 _swigt__p_wxJoystick,
32815 _swigt__p_wxSystemOptions,
32816 _swigt__p_wxPoint,
32817 _swigt__p_wxJoystickEvent,
32818 _swigt__p_wxCursor,
32819 _swigt__p_wxObject,
32820 _swigt__p_wxOutputStream,
32821 _swigt__p_wxDateTime,
32822 _swigt__p_wxPyDropSource,
32823 _swigt__p_unsigned_long,
32824 _swigt__p_wxKillError,
32825 _swigt__p_wxWindow,
32826 _swigt__p_wxString,
32827 _swigt__p_wxPyProcess,
32828 _swigt__p_wxBitmap,
32829 _swigt__p_wxConfig,
32830 _swigt__unsigned_int,
32831 _swigt__p_unsigned_int,
32832 _swigt__p_unsigned_char,
32833 _swigt__p_wxChar,
32834 _swigt__p_wxBusyInfo,
32835 _swigt__p_wxPyDropTarget,
32836 _swigt__p_wxPyTextDropTarget,
32837 _swigt__p_wxPyFileDropTarget,
32838 _swigt__p_wxProcessEvent,
32839 _swigt__p_wxPyLog,
32840 _swigt__p_wxLogNull,
32841 _swigt__p_wxColour,
32842 _swigt__p_wxPyTimer,
32843 _swigt__p_wxConfigPathChanger,
32844 _swigt__p_wxDateSpan,
32845 0
32846 };
32847
32848
32849 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32850
32851 static swig_const_info swig_const_table[] = {
32852 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32853 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32854 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32855 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32856 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32857 {0, 0, 0, 0.0, 0, 0}};
32858
32859 #ifdef __cplusplus
32860 }
32861 #endif
32862
32863
32864 #ifdef __cplusplus
32865 extern "C" {
32866 #endif
32867
32868 /* Python-specific SWIG API */
32869 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32870 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32871 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32872
32873 /* -----------------------------------------------------------------------------
32874 * global variable support code.
32875 * ----------------------------------------------------------------------------- */
32876
32877 typedef struct swig_globalvar {
32878 char *name; /* Name of global variable */
32879 PyObject *(*get_attr)(); /* Return the current value */
32880 int (*set_attr)(PyObject *); /* Set the value */
32881 struct swig_globalvar *next;
32882 } swig_globalvar;
32883
32884 typedef struct swig_varlinkobject {
32885 PyObject_HEAD
32886 swig_globalvar *vars;
32887 } swig_varlinkobject;
32888
32889 static PyObject *
32890 swig_varlink_repr(swig_varlinkobject *v) {
32891 v = v;
32892 return PyString_FromString("<Swig global variables>");
32893 }
32894
32895 static int
32896 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32897 swig_globalvar *var;
32898 flags = flags;
32899 fprintf(fp,"Swig global variables { ");
32900 for (var = v->vars; var; var=var->next) {
32901 fprintf(fp,"%s", var->name);
32902 if (var->next) fprintf(fp,", ");
32903 }
32904 fprintf(fp," }\n");
32905 return 0;
32906 }
32907
32908 static PyObject *
32909 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32910 swig_globalvar *var = v->vars;
32911 while (var) {
32912 if (strcmp(var->name,n) == 0) {
32913 return (*var->get_attr)();
32914 }
32915 var = var->next;
32916 }
32917 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32918 return NULL;
32919 }
32920
32921 static int
32922 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32923 swig_globalvar *var = v->vars;
32924 while (var) {
32925 if (strcmp(var->name,n) == 0) {
32926 return (*var->set_attr)(p);
32927 }
32928 var = var->next;
32929 }
32930 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32931 return 1;
32932 }
32933
32934 static PyTypeObject varlinktype = {
32935 PyObject_HEAD_INIT(0)
32936 0, /* Number of items in variable part (ob_size) */
32937 (char *)"swigvarlink", /* Type name (tp_name) */
32938 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32939 0, /* Itemsize (tp_itemsize) */
32940 0, /* Deallocator (tp_dealloc) */
32941 (printfunc) swig_varlink_print, /* Print (tp_print) */
32942 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32943 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32944 0, /* tp_compare */
32945 (reprfunc) swig_varlink_repr, /* tp_repr */
32946 0, /* tp_as_number */
32947 0, /* tp_as_sequence */
32948 0, /* tp_as_mapping */
32949 0, /* tp_hash */
32950 0, /* tp_call */
32951 0, /* tp_str */
32952 0, /* tp_getattro */
32953 0, /* tp_setattro */
32954 0, /* tp_as_buffer */
32955 0, /* tp_flags */
32956 0, /* tp_doc */
32957 #if PY_VERSION_HEX >= 0x02000000
32958 0, /* tp_traverse */
32959 0, /* tp_clear */
32960 #endif
32961 #if PY_VERSION_HEX >= 0x02010000
32962 0, /* tp_richcompare */
32963 0, /* tp_weaklistoffset */
32964 #endif
32965 #if PY_VERSION_HEX >= 0x02020000
32966 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32967 #endif
32968 #if PY_VERSION_HEX >= 0x02030000
32969 0, /* tp_del */
32970 #endif
32971 #ifdef COUNT_ALLOCS
32972 0,0,0,0 /* tp_alloc -> tp_next */
32973 #endif
32974 };
32975
32976 /* Create a variable linking object for use later */
32977 static PyObject *
32978 SWIG_Python_newvarlink(void) {
32979 swig_varlinkobject *result = 0;
32980 result = PyMem_NEW(swig_varlinkobject,1);
32981 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32982 result->ob_type = &varlinktype;
32983 result->vars = 0;
32984 result->ob_refcnt = 0;
32985 Py_XINCREF((PyObject *) result);
32986 return ((PyObject*) result);
32987 }
32988
32989 static void
32990 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32991 swig_varlinkobject *v;
32992 swig_globalvar *gv;
32993 v= (swig_varlinkobject *) p;
32994 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32995 gv->name = (char *) malloc(strlen(name)+1);
32996 strcpy(gv->name,name);
32997 gv->get_attr = get_attr;
32998 gv->set_attr = set_attr;
32999 gv->next = v->vars;
33000 v->vars = gv;
33001 }
33002
33003 /* -----------------------------------------------------------------------------
33004 * constants/methods manipulation
33005 * ----------------------------------------------------------------------------- */
33006
33007 /* Install Constants */
33008 static void
33009 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33010 PyObject *obj = 0;
33011 size_t i;
33012 for (i = 0; constants[i].type; i++) {
33013 switch(constants[i].type) {
33014 case SWIG_PY_INT:
33015 obj = PyInt_FromLong(constants[i].lvalue);
33016 break;
33017 case SWIG_PY_FLOAT:
33018 obj = PyFloat_FromDouble(constants[i].dvalue);
33019 break;
33020 case SWIG_PY_STRING:
33021 if (constants[i].pvalue) {
33022 obj = PyString_FromString((char *) constants[i].pvalue);
33023 } else {
33024 Py_INCREF(Py_None);
33025 obj = Py_None;
33026 }
33027 break;
33028 case SWIG_PY_POINTER:
33029 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33030 break;
33031 case SWIG_PY_BINARY:
33032 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33033 break;
33034 default:
33035 obj = 0;
33036 break;
33037 }
33038 if (obj) {
33039 PyDict_SetItemString(d,constants[i].name,obj);
33040 Py_DECREF(obj);
33041 }
33042 }
33043 }
33044
33045 /* -----------------------------------------------------------------------------*/
33046 /* Fix SwigMethods to carry the callback ptrs when needed */
33047 /* -----------------------------------------------------------------------------*/
33048
33049 static void
33050 SWIG_Python_FixMethods(PyMethodDef *methods,
33051 swig_const_info *const_table,
33052 swig_type_info **types,
33053 swig_type_info **types_initial) {
33054 size_t i;
33055 for (i = 0; methods[i].ml_name; ++i) {
33056 char *c = methods[i].ml_doc;
33057 if (c && (c = strstr(c, "swig_ptr: "))) {
33058 int j;
33059 swig_const_info *ci = 0;
33060 char *name = c + 10;
33061 for (j = 0; const_table[j].type; j++) {
33062 if (strncmp(const_table[j].name, name,
33063 strlen(const_table[j].name)) == 0) {
33064 ci = &(const_table[j]);
33065 break;
33066 }
33067 }
33068 if (ci) {
33069 size_t shift = (ci->ptype) - types;
33070 swig_type_info *ty = types_initial[shift];
33071 size_t ldoc = (c - methods[i].ml_doc);
33072 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33073 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33074 char *buff = ndoc;
33075 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33076 strncpy(buff, methods[i].ml_doc, ldoc);
33077 buff += ldoc;
33078 strncpy(buff, "swig_ptr: ", 10);
33079 buff += 10;
33080 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33081 methods[i].ml_doc = ndoc;
33082 }
33083 }
33084 }
33085 }
33086
33087 /* -----------------------------------------------------------------------------*
33088 * Initialize type list
33089 * -----------------------------------------------------------------------------*/
33090
33091 #if PY_MAJOR_VERSION < 2
33092 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33093 is copied out of Python/modsupport.c in python version 2.3.4 */
33094 static int
33095 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33096 {
33097 PyObject *dict;
33098 if (!PyModule_Check(m)) {
33099 PyErr_SetString(PyExc_TypeError,
33100 "PyModule_AddObject() needs module as first arg");
33101 return -1;
33102 }
33103 if (!o) {
33104 PyErr_SetString(PyExc_TypeError,
33105 "PyModule_AddObject() needs non-NULL value");
33106 return -1;
33107 }
33108
33109 dict = PyModule_GetDict(m);
33110 if (dict == NULL) {
33111 /* Internal error -- modules must have a dict! */
33112 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33113 PyModule_GetName(m));
33114 return -1;
33115 }
33116 if (PyDict_SetItemString(dict, name, o))
33117 return -1;
33118 Py_DECREF(o);
33119 return 0;
33120 }
33121 #endif
33122
33123 static swig_type_info **
33124 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33125 static PyMethodDef swig_empty_runtime_method_table[] = {
33126 {
33127 NULL, NULL, 0, NULL
33128 }
33129 };/* Sentinel */
33130
33131 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33132 swig_empty_runtime_method_table);
33133 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33134 if (pointer && module) {
33135 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33136 }
33137 return type_list_handle;
33138 }
33139
33140 static swig_type_info **
33141 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33142 swig_type_info **type_pointer;
33143
33144 /* first check if module already created */
33145 type_pointer = SWIG_Python_GetTypeListHandle();
33146 if (type_pointer) {
33147 return type_pointer;
33148 } else {
33149 /* create a new module and variable */
33150 return SWIG_Python_SetTypeListHandle(type_list_handle);
33151 }
33152 }
33153
33154 #ifdef __cplusplus
33155 }
33156 #endif
33157
33158 /* -----------------------------------------------------------------------------*
33159 * Partial Init method
33160 * -----------------------------------------------------------------------------*/
33161
33162 #ifdef SWIG_LINK_RUNTIME
33163 #ifdef __cplusplus
33164 extern "C"
33165 #endif
33166 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33167 #endif
33168
33169 #ifdef __cplusplus
33170 extern "C"
33171 #endif
33172 SWIGEXPORT(void) SWIG_init(void) {
33173 static PyObject *SWIG_globals = 0;
33174 static int typeinit = 0;
33175 PyObject *m, *d;
33176 int i;
33177 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33178
33179 /* Fix SwigMethods to carry the callback ptrs when needed */
33180 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33181
33182 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33183 d = PyModule_GetDict(m);
33184
33185 if (!typeinit) {
33186 #ifdef SWIG_LINK_RUNTIME
33187 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33188 #else
33189 # ifndef SWIG_STATIC_RUNTIME
33190 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33191 # endif
33192 #endif
33193 for (i = 0; swig_types_initial[i]; i++) {
33194 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33195 }
33196 typeinit = 1;
33197 }
33198 SWIG_InstallConstants(d,swig_const_table);
33199
33200 {
33201 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33316 }
33317 {
33318 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33472 }
33473 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33474 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33475 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33476 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33477 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33478 {
33479 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33489 }
33490 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33491
33492 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33493
33494 {
33495 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33526 }
33527 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33528 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33529 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33530 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33531 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33532 {
33533 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33624 }
33625 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33626 {
33627 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33640 }
33641
33642 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33643
33644 {
33645 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33664 }
33665 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33666 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33667 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33668 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33669 {
33670 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33692 }
33693 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33694 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33695 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33696 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33697 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33698 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33699 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33700 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33701 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33702 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33703 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33704 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33705 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33706 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33707 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33708 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33709 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33710 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33711 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33712 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33713 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33714 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33715 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33716 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33717 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33718 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33719 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33721 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33722 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33723 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33724 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33725 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33726 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33727 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33728 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33731 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33732 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33733 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33734 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33735 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33736 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33737 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33738 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33739 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33740 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33741 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33742 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33743 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33744 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33745 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33746 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33747 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33748 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33749
33750 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33751
33752 {
33753 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33778 }
33779 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33780 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33781 {
33782 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34245 }
34246 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34247 {
34248 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34249 }
34250 {
34251 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34252 }
34253 {
34254 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34255 }
34256 {
34257 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34258 }
34259 {
34260 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34261 }
34262 {
34263 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34264 }
34265 {
34266 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34267 }
34268 {
34269 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34306 }
34307 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34308 {
34309 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34343 }
34344
34345 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34346 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34347 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34348 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34349
34350 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34351 }
34352
wxWidgets (Impactor)